![Linus Torvalds](/assets/img/avatar_default.png)
Pull drm main changes from Dave Airlie: "This is the main drm pull request, I'm probably going to send two more smaller ones, will explain below. This contains a patch that is also in the fbdev tree, but it should be the same patch, it added an API for hot unplugging framebuffer devices, and I need that API for a new driver. It also contains some changes to the i2c tree which Jean has acked, and one change to moorestown platform stuff in x86. Highlights: - new drivers: UDL driver for USB displaylink devices, kms only, should support correct hotplug operations. - core: i2c speedups + better hotplug support, EDID overriding via firmware interface - allows user to load a firmware for a broken monitor/kvm from userspace, it even has documentation for it. - exynos: new HDMI audio + hdmi 1.4 + virtual output driver - gma500: code cleanup - radeon: cleanups, CS optimisations, streamout support and pageflip fix - nouveau: NVD9 displayport support + more reclocking work - i915: re-enabling GMBUS, finish gpu patch (might help hibernation who knows), missed irq fixes, stencil tiling fixes, interlaced support, aliasesd PPGTT support for SNB/IVB, swizzling for SNB/IVB, semaphore fixes As well as the usual bunch of cleanups and fixes all over the place. I've got two things I'd like to merge a bit later: a) AMD support for all their new radeonhd 7000 series GPU and APUs. AMD dropped this a bit late due to insane internal review processes, (please AMD just follow Intel and let open source guys ship stuff early) however I don't want to penalise people who own this hardware (since its been on sale for 3-4 months and GPU hw doesn't exactly have a lifetime in years) and consign them to using closed drivers for longer than necessary. The changes are well contained and just plug into the driver new gpu functionality so they should be fairly regression proof. I just want to give them a bit of a run on the hw AMD kindly sent me. b) drm prime/dma-buf interface code. This is just infrastructure code to expose the dma-buf stuff to drm drivers and to userspace. I'm not planning on pushing any driver support in this cycle (except maybe exynos), but I'd like to get the infrastructure code in so for the next cycle I can start getting the driver support into the individual drivers. We have started driver support for i915, nouveau and udl along with I think exynos and omap in staging. However this code relies on the dma-buf tree being pulled into your tree first since it needs the latest interfaces from that tree. I'll push to get that tree sent asap. (oh and any warnings you see in i915 are gcc's fault from what anyone can see)." Fix up trivial conflicts in arch/x86/platform/mrst/mrst.c due to the new msic_thermal_platform_data() thermal function being added next to the tc35876x_platform_data() i2c device function.. * 'drm-next' of git://people.freedesktop.org/~airlied/linux: (326 commits) drm/i915: use DDC_ADDR instead of hard-coding it drm/radeon: use DDC_ADDR instead of hard-coding it drm: remove unneeded redefinition of DDC_ADDR drm/exynos: added virtual display driver. drm: allow loading an EDID as firmware to override broken monitor drm/exynos: enable hdmi audio feature drm/exynos: add default pixel format for plane drm/exynos: cleanup exynos_hdmi.h drm/exynos: add is_local member in exynos_drm_subdrv struct drm/exynos: add subdrv open/close functions drm/exynos: remove module of exynos drm subdrv drm/exynos: release pending pageflip events when closed drm/exynos: added new funtion to get/put dma address. drm/exynos: update gem and buffer framework. drm/exynos: added mode_fixup feature and code clean. drm/exynos: add HDMI version 1.4 support drm/exynos: remove exynos_mixer.h gma500: Fix mmap frambuffer drm/radeon: Drop radeon_gem_object_(un)pin. drm/radeon: Restrict offset for legacy display engine. ...
355 lines
10 KiB
C
355 lines
10 KiB
C
/*
|
|
* Copyright (c) 2011 Samsung Electronics Co., Ltd.
|
|
* Authors:
|
|
* Inki Dae <inki.dae@samsung.com>
|
|
* Joonyoung Shim <jy0922.shim@samsung.com>
|
|
* Seung-Woo Kim <sw0312.kim@samsung.com>
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the next
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
* Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include "drmP.h"
|
|
#include "drm_crtc_helper.h"
|
|
|
|
#include <drm/exynos_drm.h>
|
|
#include "exynos_drm_drv.h"
|
|
#include "exynos_drm_encoder.h"
|
|
|
|
#define MAX_EDID 256
|
|
#define to_exynos_connector(x) container_of(x, struct exynos_drm_connector,\
|
|
drm_connector)
|
|
|
|
struct exynos_drm_connector {
|
|
struct drm_connector drm_connector;
|
|
uint32_t encoder_id;
|
|
struct exynos_drm_manager *manager;
|
|
};
|
|
|
|
/* convert exynos_video_timings to drm_display_mode */
|
|
static inline void
|
|
convert_to_display_mode(struct drm_display_mode *mode,
|
|
struct exynos_drm_panel_info *panel)
|
|
{
|
|
struct fb_videomode *timing = &panel->timing;
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
mode->clock = timing->pixclock / 1000;
|
|
mode->vrefresh = timing->refresh;
|
|
|
|
mode->hdisplay = timing->xres;
|
|
mode->hsync_start = mode->hdisplay + timing->right_margin;
|
|
mode->hsync_end = mode->hsync_start + timing->hsync_len;
|
|
mode->htotal = mode->hsync_end + timing->left_margin;
|
|
|
|
mode->vdisplay = timing->yres;
|
|
mode->vsync_start = mode->vdisplay + timing->lower_margin;
|
|
mode->vsync_end = mode->vsync_start + timing->vsync_len;
|
|
mode->vtotal = mode->vsync_end + timing->upper_margin;
|
|
mode->width_mm = panel->width_mm;
|
|
mode->height_mm = panel->height_mm;
|
|
|
|
if (timing->vmode & FB_VMODE_INTERLACED)
|
|
mode->flags |= DRM_MODE_FLAG_INTERLACE;
|
|
|
|
if (timing->vmode & FB_VMODE_DOUBLE)
|
|
mode->flags |= DRM_MODE_FLAG_DBLSCAN;
|
|
}
|
|
|
|
/* convert drm_display_mode to exynos_video_timings */
|
|
static inline void
|
|
convert_to_video_timing(struct fb_videomode *timing,
|
|
struct drm_display_mode *mode)
|
|
{
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
memset(timing, 0, sizeof(*timing));
|
|
|
|
timing->pixclock = mode->clock * 1000;
|
|
timing->refresh = drm_mode_vrefresh(mode);
|
|
|
|
timing->xres = mode->hdisplay;
|
|
timing->right_margin = mode->hsync_start - mode->hdisplay;
|
|
timing->hsync_len = mode->hsync_end - mode->hsync_start;
|
|
timing->left_margin = mode->htotal - mode->hsync_end;
|
|
|
|
timing->yres = mode->vdisplay;
|
|
timing->lower_margin = mode->vsync_start - mode->vdisplay;
|
|
timing->vsync_len = mode->vsync_end - mode->vsync_start;
|
|
timing->upper_margin = mode->vtotal - mode->vsync_end;
|
|
|
|
if (mode->flags & DRM_MODE_FLAG_INTERLACE)
|
|
timing->vmode = FB_VMODE_INTERLACED;
|
|
else
|
|
timing->vmode = FB_VMODE_NONINTERLACED;
|
|
|
|
if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
|
|
timing->vmode |= FB_VMODE_DOUBLE;
|
|
}
|
|
|
|
static int exynos_drm_connector_get_modes(struct drm_connector *connector)
|
|
{
|
|
struct exynos_drm_connector *exynos_connector =
|
|
to_exynos_connector(connector);
|
|
struct exynos_drm_manager *manager = exynos_connector->manager;
|
|
struct exynos_drm_display_ops *display_ops = manager->display_ops;
|
|
unsigned int count;
|
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
if (!display_ops) {
|
|
DRM_DEBUG_KMS("display_ops is null.\n");
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* if get_edid() exists then get_edid() callback of hdmi side
|
|
* is called to get edid data through i2c interface else
|
|
* get timing from the FIMD driver(display controller).
|
|
*
|
|
* P.S. in case of lcd panel, count is always 1 if success
|
|
* because lcd panel has only one mode.
|
|
*/
|
|
if (display_ops->get_edid) {
|
|
int ret;
|
|
void *edid;
|
|
|
|
edid = kzalloc(MAX_EDID, GFP_KERNEL);
|
|
if (!edid) {
|
|
DRM_ERROR("failed to allocate edid\n");
|
|
return 0;
|
|
}
|
|
|
|
ret = display_ops->get_edid(manager->dev, connector,
|
|
edid, MAX_EDID);
|
|
if (ret < 0) {
|
|
DRM_ERROR("failed to get edid data.\n");
|
|
kfree(edid);
|
|
edid = NULL;
|
|
return 0;
|
|
}
|
|
|
|
drm_mode_connector_update_edid_property(connector, edid);
|
|
count = drm_add_edid_modes(connector, edid);
|
|
|
|
kfree(connector->display_info.raw_edid);
|
|
connector->display_info.raw_edid = edid;
|
|
} else {
|
|
struct drm_display_mode *mode = drm_mode_create(connector->dev);
|
|
struct exynos_drm_panel_info *panel;
|
|
|
|
if (display_ops->get_panel)
|
|
panel = display_ops->get_panel(manager->dev);
|
|
else {
|
|
drm_mode_destroy(connector->dev, mode);
|
|
return 0;
|
|
}
|
|
|
|
convert_to_display_mode(mode, panel);
|
|
connector->display_info.width_mm = mode->width_mm;
|
|
connector->display_info.height_mm = mode->height_mm;
|
|
|
|
mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
|
|
drm_mode_set_name(mode);
|
|
drm_mode_probed_add(connector, mode);
|
|
|
|
count = 1;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
static int exynos_drm_connector_mode_valid(struct drm_connector *connector,
|
|
struct drm_display_mode *mode)
|
|
{
|
|
struct exynos_drm_connector *exynos_connector =
|
|
to_exynos_connector(connector);
|
|
struct exynos_drm_manager *manager = exynos_connector->manager;
|
|
struct exynos_drm_display_ops *display_ops = manager->display_ops;
|
|
struct fb_videomode timing;
|
|
int ret = MODE_BAD;
|
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
convert_to_video_timing(&timing, mode);
|
|
|
|
if (display_ops && display_ops->check_timing)
|
|
if (!display_ops->check_timing(manager->dev, (void *)&timing))
|
|
ret = MODE_OK;
|
|
|
|
return ret;
|
|
}
|
|
|
|
struct drm_encoder *exynos_drm_best_encoder(struct drm_connector *connector)
|
|
{
|
|
struct drm_device *dev = connector->dev;
|
|
struct exynos_drm_connector *exynos_connector =
|
|
to_exynos_connector(connector);
|
|
struct drm_mode_object *obj;
|
|
struct drm_encoder *encoder;
|
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
obj = drm_mode_object_find(dev, exynos_connector->encoder_id,
|
|
DRM_MODE_OBJECT_ENCODER);
|
|
if (!obj) {
|
|
DRM_DEBUG_KMS("Unknown ENCODER ID %d\n",
|
|
exynos_connector->encoder_id);
|
|
return NULL;
|
|
}
|
|
|
|
encoder = obj_to_encoder(obj);
|
|
|
|
return encoder;
|
|
}
|
|
|
|
static struct drm_connector_helper_funcs exynos_connector_helper_funcs = {
|
|
.get_modes = exynos_drm_connector_get_modes,
|
|
.mode_valid = exynos_drm_connector_mode_valid,
|
|
.best_encoder = exynos_drm_best_encoder,
|
|
};
|
|
|
|
static int exynos_drm_connector_fill_modes(struct drm_connector *connector,
|
|
unsigned int max_width, unsigned int max_height)
|
|
{
|
|
struct exynos_drm_connector *exynos_connector =
|
|
to_exynos_connector(connector);
|
|
struct exynos_drm_manager *manager = exynos_connector->manager;
|
|
struct exynos_drm_manager_ops *ops = manager->ops;
|
|
unsigned int width, height;
|
|
|
|
width = max_width;
|
|
height = max_height;
|
|
|
|
/*
|
|
* if specific driver want to find desired_mode using maxmum
|
|
* resolution then get max width and height from that driver.
|
|
*/
|
|
if (ops && ops->get_max_resol)
|
|
ops->get_max_resol(manager->dev, &width, &height);
|
|
|
|
return drm_helper_probe_single_connector_modes(connector, width,
|
|
height);
|
|
}
|
|
|
|
/* get detection status of display device. */
|
|
static enum drm_connector_status
|
|
exynos_drm_connector_detect(struct drm_connector *connector, bool force)
|
|
{
|
|
struct exynos_drm_connector *exynos_connector =
|
|
to_exynos_connector(connector);
|
|
struct exynos_drm_manager *manager = exynos_connector->manager;
|
|
struct exynos_drm_display_ops *display_ops =
|
|
manager->display_ops;
|
|
enum drm_connector_status status = connector_status_disconnected;
|
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
if (display_ops && display_ops->is_connected) {
|
|
if (display_ops->is_connected(manager->dev))
|
|
status = connector_status_connected;
|
|
else
|
|
status = connector_status_disconnected;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
static void exynos_drm_connector_destroy(struct drm_connector *connector)
|
|
{
|
|
struct exynos_drm_connector *exynos_connector =
|
|
to_exynos_connector(connector);
|
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
drm_sysfs_connector_remove(connector);
|
|
drm_connector_cleanup(connector);
|
|
kfree(exynos_connector);
|
|
}
|
|
|
|
static struct drm_connector_funcs exynos_connector_funcs = {
|
|
.dpms = drm_helper_connector_dpms,
|
|
.fill_modes = exynos_drm_connector_fill_modes,
|
|
.detect = exynos_drm_connector_detect,
|
|
.destroy = exynos_drm_connector_destroy,
|
|
};
|
|
|
|
struct drm_connector *exynos_drm_connector_create(struct drm_device *dev,
|
|
struct drm_encoder *encoder)
|
|
{
|
|
struct exynos_drm_connector *exynos_connector;
|
|
struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
|
|
struct drm_connector *connector;
|
|
int type;
|
|
int err;
|
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
exynos_connector = kzalloc(sizeof(*exynos_connector), GFP_KERNEL);
|
|
if (!exynos_connector) {
|
|
DRM_ERROR("failed to allocate connector\n");
|
|
return NULL;
|
|
}
|
|
|
|
connector = &exynos_connector->drm_connector;
|
|
|
|
switch (manager->display_ops->type) {
|
|
case EXYNOS_DISPLAY_TYPE_HDMI:
|
|
type = DRM_MODE_CONNECTOR_HDMIA;
|
|
connector->interlace_allowed = true;
|
|
connector->polled = DRM_CONNECTOR_POLL_HPD;
|
|
break;
|
|
case EXYNOS_DISPLAY_TYPE_VIDI:
|
|
type = DRM_MODE_CONNECTOR_VIRTUAL;
|
|
connector->polled = DRM_CONNECTOR_POLL_HPD;
|
|
break;
|
|
default:
|
|
type = DRM_MODE_CONNECTOR_Unknown;
|
|
break;
|
|
}
|
|
|
|
drm_connector_init(dev, connector, &exynos_connector_funcs, type);
|
|
drm_connector_helper_add(connector, &exynos_connector_helper_funcs);
|
|
|
|
err = drm_sysfs_connector_add(connector);
|
|
if (err)
|
|
goto err_connector;
|
|
|
|
exynos_connector->encoder_id = encoder->base.id;
|
|
exynos_connector->manager = manager;
|
|
connector->encoder = encoder;
|
|
|
|
err = drm_mode_connector_attach_encoder(connector, encoder);
|
|
if (err) {
|
|
DRM_ERROR("failed to attach a connector to a encoder\n");
|
|
goto err_sysfs;
|
|
}
|
|
|
|
DRM_DEBUG_KMS("connector has been created\n");
|
|
|
|
return connector;
|
|
|
|
err_sysfs:
|
|
drm_sysfs_connector_remove(connector);
|
|
err_connector:
|
|
drm_connector_cleanup(connector);
|
|
kfree(exynos_connector);
|
|
return NULL;
|
|
}
|