2011-10-04 17:19:01 +07:00
|
|
|
/*
|
|
|
|
* 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>
|
|
|
|
*
|
2012-12-18 00:30:17 +07:00
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms of the GNU General Public License as published by the
|
|
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
|
|
* option) any later version.
|
2011-10-04 17:19:01 +07:00
|
|
|
*/
|
|
|
|
|
2014-01-31 04:19:27 +07:00
|
|
|
#include <linux/pm_runtime.h>
|
2012-10-03 00:01:07 +07:00
|
|
|
#include <drm/drmP.h>
|
|
|
|
#include <drm/drm_crtc_helper.h>
|
2011-10-04 17:19:01 +07:00
|
|
|
|
2014-05-09 12:25:20 +07:00
|
|
|
#include <linux/component.h>
|
2013-12-20 17:16:24 +07:00
|
|
|
|
2011-10-04 17:19:01 +07:00
|
|
|
#include <drm/exynos_drm.h>
|
|
|
|
|
|
|
|
#include "exynos_drm_drv.h"
|
|
|
|
#include "exynos_drm_crtc.h"
|
2012-02-15 09:25:19 +07:00
|
|
|
#include "exynos_drm_encoder.h"
|
2011-10-04 17:19:01 +07:00
|
|
|
#include "exynos_drm_fbdev.h"
|
|
|
|
#include "exynos_drm_fb.h"
|
|
|
|
#include "exynos_drm_gem.h"
|
2011-12-08 15:54:07 +07:00
|
|
|
#include "exynos_drm_plane.h"
|
2012-03-21 08:55:26 +07:00
|
|
|
#include "exynos_drm_vidi.h"
|
2012-04-23 19:01:28 +07:00
|
|
|
#include "exynos_drm_dmabuf.h"
|
2012-05-17 18:06:32 +07:00
|
|
|
#include "exynos_drm_g2d.h"
|
drm/exynos: add ipp subsystem
This patch adds Image Post Processing(IPP) support for exynos drm driver.
IPP supports image scaler/rotator and input/output DMA operations
using IPP subsystem framework to control FIMC, Rotator and GSC hardware
and supports some user interfaces for user side.
And each IPP-based drivers support Memory to Memory operations
with various converting. And in case of FIMC hardware, it also supports
Writeback and Display output operations through local path.
Features:
- Memory to Memory operation support.
- Various pixel formats support.
- Image scaling support.
- Color Space Conversion support.
- Image crop operation support.
- Rotate operation support to 90, 180 or 270 degree.
- Flip operation support to vertical, horizontal or both.
- Writeback operation support to display blended image of FIMD fifo on screen
A summary to IPP Subsystem operations:
First of all, user should get property capabilities from IPP subsystem
and set these properties to hardware registers for desired operations.
The properties could be pixel format, position, rotation degree and
flip operation.
And next, user should set source and destination buffer data using
DRM_EXYNOS_IPP_QUEUE_BUF ioctl command with gem handles to source and
destinition buffers.
And next, user can control user-desired hardware with desired operations
such as play, stop, pause and resume controls.
And finally, user can aware of dma operation completion and also get
destination buffer that it contains user-desried result through dequeue
command.
IOCTL commands:
- DRM_EXYNOS_IPP_GET_PROPERTY
. get ipp driver capabilitis and id.
- DRM_EXYNOS_IPP_SET_PROPERTY
. set format, position, rotation, flip to source and destination buffers
- DRM_EXYNOS_IPP_QUEUE_BUF
. enqueue/dequeue buffer and make event list.
- DRM_EXYNOS_IPP_CMD_CTRL
. play/stop/pause/resume control.
Event:
- DRM_EXYNOS_IPP_EVENT
. a event to notify dma operation completion to user side.
Basic control flow:
Open -> Get properties -> User choose desired IPP sub driver(FIMC, Rotator
or GSCALER) -> Set Property -> Create gem handle -> Enqueue to source and
destination buffers -> Command control(Play) -> Event is notified to User
-> User gets destinition buffer complated -> (Enqueue to source and
destination buffers -> Event is notified to User) * N -> Queue/Dequeue to
source and destination buffers -> Command control(Stop) -> Free gem handle
-> Close
Changelog v1 ~ v5:
- added comments, code fixups and cleanups.
Signed-off-by: Eunchul Kim <chulspro.kim@samsung.com>
Signed-off-by: Jinyoung Jeon <jy0.jeon@samsung.com>
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-12-14 16:10:31 +07:00
|
|
|
#include "exynos_drm_ipp.h"
|
2012-10-20 21:53:42 +07:00
|
|
|
#include "exynos_drm_iommu.h"
|
2011-10-04 17:19:01 +07:00
|
|
|
|
2011-12-15 15:31:24 +07:00
|
|
|
#define DRIVER_NAME "exynos"
|
2011-10-04 17:19:01 +07:00
|
|
|
#define DRIVER_DESC "Samsung SoC DRM"
|
|
|
|
#define DRIVER_DATE "20110530"
|
|
|
|
#define DRIVER_MAJOR 1
|
|
|
|
#define DRIVER_MINOR 0
|
|
|
|
|
2012-10-16 07:20:12 +07:00
|
|
|
static struct platform_device *exynos_drm_pdev;
|
|
|
|
|
2014-05-09 12:25:20 +07:00
|
|
|
static DEFINE_MUTEX(drm_component_lock);
|
|
|
|
static LIST_HEAD(drm_component_list);
|
|
|
|
|
|
|
|
struct component_dev {
|
|
|
|
struct list_head list;
|
2014-05-29 16:28:02 +07:00
|
|
|
struct device *crtc_dev;
|
|
|
|
struct device *conn_dev;
|
|
|
|
enum exynos_drm_output_type out_type;
|
|
|
|
unsigned int dev_type_flag;
|
2014-05-09 12:25:20 +07:00
|
|
|
};
|
|
|
|
|
2011-10-04 17:19:01 +07:00
|
|
|
static int exynos_drm_load(struct drm_device *dev, unsigned long flags)
|
|
|
|
{
|
|
|
|
struct exynos_drm_private *private;
|
|
|
|
int ret;
|
|
|
|
int nr;
|
|
|
|
|
|
|
|
private = kzalloc(sizeof(struct exynos_drm_private), GFP_KERNEL);
|
2013-08-19 17:04:55 +07:00
|
|
|
if (!private)
|
2011-10-04 17:19:01 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&private->pageflip_event_list);
|
2014-01-31 04:19:27 +07:00
|
|
|
dev_set_drvdata(dev->dev, dev);
|
2011-10-04 17:19:01 +07:00
|
|
|
dev->dev_private = (void *)private;
|
|
|
|
|
2012-10-20 21:53:42 +07:00
|
|
|
/*
|
|
|
|
* create mapping to manage iommu table and set a pointer to iommu
|
|
|
|
* mapping structure to iommu_mapping of private data.
|
|
|
|
* also this iommu_mapping can be used to check if iommu is supported
|
|
|
|
* or not.
|
|
|
|
*/
|
|
|
|
ret = drm_create_iommu_mapping(dev);
|
|
|
|
if (ret < 0) {
|
|
|
|
DRM_ERROR("failed to create iommu mapping.\n");
|
2014-02-28 16:37:02 +07:00
|
|
|
goto err_free_private;
|
2012-10-20 21:53:42 +07:00
|
|
|
}
|
|
|
|
|
2011-10-04 17:19:01 +07:00
|
|
|
drm_mode_config_init(dev);
|
|
|
|
|
|
|
|
exynos_drm_mode_config_init(dev);
|
|
|
|
|
2011-12-08 15:54:07 +07:00
|
|
|
for (nr = 0; nr < MAX_PLANE; nr++) {
|
2012-06-27 12:27:04 +07:00
|
|
|
struct drm_plane *plane;
|
2014-01-31 04:19:11 +07:00
|
|
|
unsigned long possible_crtcs = (1 << MAX_CRTC) - 1;
|
2012-06-27 12:27:04 +07:00
|
|
|
|
2014-09-19 19:58:53 +07:00
|
|
|
plane = exynos_plane_init(dev, possible_crtcs,
|
|
|
|
DRM_PLANE_TYPE_OVERLAY);
|
2014-10-10 19:31:53 +07:00
|
|
|
if (!IS_ERR(plane))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = PTR_ERR(plane);
|
|
|
|
goto err_mode_config_cleanup;
|
2011-12-08 15:54:07 +07:00
|
|
|
}
|
|
|
|
|
2012-02-15 09:25:19 +07:00
|
|
|
/* setup possible_clones. */
|
|
|
|
exynos_drm_encoder_setup(dev);
|
|
|
|
|
2013-12-11 17:34:23 +07:00
|
|
|
platform_set_drvdata(dev->platformdev, dev);
|
|
|
|
|
2014-05-09 12:25:20 +07:00
|
|
|
/* Try to bind all sub drivers. */
|
|
|
|
ret = component_bind_all(dev->dev, dev);
|
|
|
|
if (ret)
|
2014-10-07 20:09:14 +07:00
|
|
|
goto err_mode_config_cleanup;
|
|
|
|
|
|
|
|
ret = drm_vblank_init(dev, dev->mode_config.num_crtc);
|
|
|
|
if (ret)
|
|
|
|
goto err_unbind_all;
|
2014-05-09 12:25:20 +07:00
|
|
|
|
2014-04-14 10:55:55 +07:00
|
|
|
/* Probe non kms sub drivers and virtual display driver. */
|
2014-05-09 12:25:20 +07:00
|
|
|
ret = exynos_drm_device_subdrv_probe(dev);
|
|
|
|
if (ret)
|
2014-10-07 20:09:14 +07:00
|
|
|
goto err_cleanup_vblank;
|
2014-05-09 12:25:20 +07:00
|
|
|
|
2014-09-18 15:50:35 +07:00
|
|
|
/*
|
|
|
|
* enable drm irq mode.
|
|
|
|
* - with irq_enabled = true, we can use the vblank feature.
|
|
|
|
*
|
|
|
|
* P.S. note that we wouldn't use drm irq handler but
|
|
|
|
* just specific driver own one instead because
|
|
|
|
* drm framework supports only one irq handler.
|
|
|
|
*/
|
|
|
|
dev->irq_enabled = true;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* with vblank_disable_allowed = true, vblank interrupt will be disabled
|
|
|
|
* by drm timer once a current process gives up ownership of
|
|
|
|
* vblank event.(after drm_vblank_put function is called)
|
|
|
|
*/
|
|
|
|
dev->vblank_disable_allowed = true;
|
|
|
|
|
2014-10-10 19:31:54 +07:00
|
|
|
/* init kms poll for handling hpd */
|
|
|
|
drm_kms_helper_poll_init(dev);
|
|
|
|
|
|
|
|
/* force connectors detection */
|
|
|
|
drm_helper_hpd_irq_event(dev);
|
|
|
|
|
2011-10-04 17:19:01 +07:00
|
|
|
return 0;
|
|
|
|
|
2014-05-09 12:25:20 +07:00
|
|
|
err_cleanup_vblank:
|
2011-10-04 17:19:01 +07:00
|
|
|
drm_vblank_cleanup(dev);
|
2014-10-07 20:09:14 +07:00
|
|
|
err_unbind_all:
|
|
|
|
component_unbind_all(dev->dev, dev);
|
2014-02-19 19:02:55 +07:00
|
|
|
err_mode_config_cleanup:
|
|
|
|
drm_mode_config_cleanup(dev);
|
2012-10-20 21:53:42 +07:00
|
|
|
drm_release_iommu_mapping(dev);
|
2014-02-28 16:37:02 +07:00
|
|
|
err_free_private:
|
2011-10-04 17:19:01 +07:00
|
|
|
kfree(private);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int exynos_drm_unload(struct drm_device *dev)
|
|
|
|
{
|
2014-05-09 12:25:20 +07:00
|
|
|
exynos_drm_device_subdrv_remove(dev);
|
|
|
|
|
2011-10-04 17:19:01 +07:00
|
|
|
exynos_drm_fbdev_fini(dev);
|
2011-10-18 14:58:05 +07:00
|
|
|
drm_kms_helper_poll_fini(dev);
|
2012-10-20 21:53:42 +07:00
|
|
|
|
2014-09-09 20:16:06 +07:00
|
|
|
drm_vblank_cleanup(dev);
|
2014-10-07 20:09:14 +07:00
|
|
|
component_unbind_all(dev->dev, dev);
|
2014-09-09 20:16:06 +07:00
|
|
|
drm_mode_config_cleanup(dev);
|
2012-10-20 21:53:42 +07:00
|
|
|
drm_release_iommu_mapping(dev);
|
2011-10-04 17:19:01 +07:00
|
|
|
|
2014-09-09 20:16:06 +07:00
|
|
|
kfree(dev->dev_private);
|
2011-10-04 17:19:01 +07:00
|
|
|
dev->dev_private = NULL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-01-31 04:19:27 +07:00
|
|
|
static int exynos_drm_suspend(struct drm_device *dev, pm_message_t state)
|
|
|
|
{
|
|
|
|
struct drm_connector *connector;
|
|
|
|
|
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
|
|
|
|
int old_dpms = connector->dpms;
|
|
|
|
|
|
|
|
if (connector->funcs->dpms)
|
|
|
|
connector->funcs->dpms(connector, DRM_MODE_DPMS_OFF);
|
|
|
|
|
|
|
|
/* Set the old mode back to the connector for resume */
|
|
|
|
connector->dpms = old_dpms;
|
|
|
|
}
|
|
|
|
drm_modeset_unlock_all(dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int exynos_drm_resume(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_connector *connector;
|
|
|
|
|
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
|
2014-10-10 19:31:56 +07:00
|
|
|
if (connector->funcs->dpms) {
|
|
|
|
int dpms = connector->dpms;
|
|
|
|
|
|
|
|
connector->dpms = DRM_MODE_DPMS_OFF;
|
|
|
|
connector->funcs->dpms(connector, dpms);
|
|
|
|
}
|
2014-01-31 04:19:27 +07:00
|
|
|
}
|
2014-05-09 13:14:15 +07:00
|
|
|
drm_modeset_unlock_all(dev);
|
2014-01-31 04:19:27 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-03-16 16:47:09 +07:00
|
|
|
static int exynos_drm_open(struct drm_device *dev, struct drm_file *file)
|
|
|
|
{
|
2012-05-17 18:06:32 +07:00
|
|
|
struct drm_exynos_file_private *file_priv;
|
2013-07-01 15:00:47 +07:00
|
|
|
int ret;
|
2012-05-17 18:06:32 +07:00
|
|
|
|
|
|
|
file_priv = kzalloc(sizeof(*file_priv), GFP_KERNEL);
|
|
|
|
if (!file_priv)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
file->driver_priv = file_priv;
|
2012-04-23 19:01:28 +07:00
|
|
|
|
2013-07-01 15:00:47 +07:00
|
|
|
ret = exynos_drm_subdrv_open(dev, file);
|
2014-01-16 13:01:26 +07:00
|
|
|
if (ret)
|
2014-03-17 10:28:06 +07:00
|
|
|
goto err_file_priv_free;
|
2013-07-01 15:00:47 +07:00
|
|
|
|
2014-01-16 13:01:26 +07:00
|
|
|
return ret;
|
2014-03-17 10:28:06 +07:00
|
|
|
|
|
|
|
err_file_priv_free:
|
2014-01-16 13:01:26 +07:00
|
|
|
kfree(file_priv);
|
|
|
|
file->driver_priv = NULL;
|
2013-07-01 15:00:47 +07:00
|
|
|
return ret;
|
2012-03-16 16:47:09 +07:00
|
|
|
}
|
|
|
|
|
2011-10-14 11:29:51 +07:00
|
|
|
static void exynos_drm_preclose(struct drm_device *dev,
|
2012-02-15 09:25:18 +07:00
|
|
|
struct drm_file *file)
|
2013-10-01 12:51:37 +07:00
|
|
|
{
|
|
|
|
exynos_drm_subdrv_close(dev, file);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void exynos_drm_postclose(struct drm_device *dev, struct drm_file *file)
|
2011-10-14 11:29:51 +07:00
|
|
|
{
|
2012-03-16 16:47:07 +07:00
|
|
|
struct exynos_drm_private *private = dev->dev_private;
|
2013-10-01 12:51:37 +07:00
|
|
|
struct drm_pending_vblank_event *v, *vt;
|
|
|
|
struct drm_pending_event *e, *et;
|
2012-03-16 16:47:07 +07:00
|
|
|
unsigned long flags;
|
|
|
|
|
2013-10-01 12:51:37 +07:00
|
|
|
if (!file->driver_priv)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Release all events not unhandled by page flip handler. */
|
2012-03-16 16:47:07 +07:00
|
|
|
spin_lock_irqsave(&dev->event_lock, flags);
|
2013-10-01 12:51:37 +07:00
|
|
|
list_for_each_entry_safe(v, vt, &private->pageflip_event_list,
|
2012-03-16 16:47:07 +07:00
|
|
|
base.link) {
|
2013-10-01 12:51:37 +07:00
|
|
|
if (v->base.file_priv == file) {
|
|
|
|
list_del(&v->base.link);
|
|
|
|
drm_vblank_put(dev, v->pipe);
|
|
|
|
v->base.destroy(&v->base);
|
2012-03-16 16:47:07 +07:00
|
|
|
}
|
|
|
|
}
|
2012-03-16 16:47:09 +07:00
|
|
|
|
2013-10-01 12:51:37 +07:00
|
|
|
/* Release all events handled by page flip handler but not freed. */
|
|
|
|
list_for_each_entry_safe(e, et, &file->event_list, link) {
|
|
|
|
list_del(&e->link);
|
|
|
|
e->destroy(e);
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
2011-10-14 11:29:51 +07:00
|
|
|
|
2012-02-15 09:25:22 +07:00
|
|
|
kfree(file->driver_priv);
|
|
|
|
file->driver_priv = NULL;
|
|
|
|
}
|
|
|
|
|
2011-10-04 17:19:01 +07:00
|
|
|
static void exynos_drm_lastclose(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
exynos_drm_fbdev_restore_mode(dev);
|
|
|
|
}
|
|
|
|
|
2012-05-17 18:27:22 +07:00
|
|
|
static const struct vm_operations_struct exynos_drm_gem_vm_ops = {
|
2011-10-04 17:19:01 +07:00
|
|
|
.fault = exynos_drm_gem_fault,
|
|
|
|
.open = drm_gem_vm_open,
|
|
|
|
.close = drm_gem_vm_close,
|
|
|
|
};
|
|
|
|
|
2013-08-03 00:27:49 +07:00
|
|
|
static const struct drm_ioctl_desc exynos_ioctls[] = {
|
2011-10-04 17:19:01 +07:00
|
|
|
DRM_IOCTL_DEF_DRV(EXYNOS_GEM_CREATE, exynos_drm_gem_create_ioctl,
|
|
|
|
DRM_UNLOCKED | DRM_AUTH),
|
2012-05-04 13:51:17 +07:00
|
|
|
DRM_IOCTL_DEF_DRV(EXYNOS_GEM_GET,
|
|
|
|
exynos_drm_gem_get_ioctl, DRM_UNLOCKED),
|
2012-03-21 08:55:26 +07:00
|
|
|
DRM_IOCTL_DEF_DRV(EXYNOS_VIDI_CONNECTION,
|
|
|
|
vidi_connection_ioctl, DRM_UNLOCKED | DRM_AUTH),
|
2012-05-17 18:06:32 +07:00
|
|
|
DRM_IOCTL_DEF_DRV(EXYNOS_G2D_GET_VER,
|
|
|
|
exynos_g2d_get_ver_ioctl, DRM_UNLOCKED | DRM_AUTH),
|
|
|
|
DRM_IOCTL_DEF_DRV(EXYNOS_G2D_SET_CMDLIST,
|
|
|
|
exynos_g2d_set_cmdlist_ioctl, DRM_UNLOCKED | DRM_AUTH),
|
|
|
|
DRM_IOCTL_DEF_DRV(EXYNOS_G2D_EXEC,
|
|
|
|
exynos_g2d_exec_ioctl, DRM_UNLOCKED | DRM_AUTH),
|
drm/exynos: add ipp subsystem
This patch adds Image Post Processing(IPP) support for exynos drm driver.
IPP supports image scaler/rotator and input/output DMA operations
using IPP subsystem framework to control FIMC, Rotator and GSC hardware
and supports some user interfaces for user side.
And each IPP-based drivers support Memory to Memory operations
with various converting. And in case of FIMC hardware, it also supports
Writeback and Display output operations through local path.
Features:
- Memory to Memory operation support.
- Various pixel formats support.
- Image scaling support.
- Color Space Conversion support.
- Image crop operation support.
- Rotate operation support to 90, 180 or 270 degree.
- Flip operation support to vertical, horizontal or both.
- Writeback operation support to display blended image of FIMD fifo on screen
A summary to IPP Subsystem operations:
First of all, user should get property capabilities from IPP subsystem
and set these properties to hardware registers for desired operations.
The properties could be pixel format, position, rotation degree and
flip operation.
And next, user should set source and destination buffer data using
DRM_EXYNOS_IPP_QUEUE_BUF ioctl command with gem handles to source and
destinition buffers.
And next, user can control user-desired hardware with desired operations
such as play, stop, pause and resume controls.
And finally, user can aware of dma operation completion and also get
destination buffer that it contains user-desried result through dequeue
command.
IOCTL commands:
- DRM_EXYNOS_IPP_GET_PROPERTY
. get ipp driver capabilitis and id.
- DRM_EXYNOS_IPP_SET_PROPERTY
. set format, position, rotation, flip to source and destination buffers
- DRM_EXYNOS_IPP_QUEUE_BUF
. enqueue/dequeue buffer and make event list.
- DRM_EXYNOS_IPP_CMD_CTRL
. play/stop/pause/resume control.
Event:
- DRM_EXYNOS_IPP_EVENT
. a event to notify dma operation completion to user side.
Basic control flow:
Open -> Get properties -> User choose desired IPP sub driver(FIMC, Rotator
or GSCALER) -> Set Property -> Create gem handle -> Enqueue to source and
destination buffers -> Command control(Play) -> Event is notified to User
-> User gets destinition buffer complated -> (Enqueue to source and
destination buffers -> Event is notified to User) * N -> Queue/Dequeue to
source and destination buffers -> Command control(Stop) -> Free gem handle
-> Close
Changelog v1 ~ v5:
- added comments, code fixups and cleanups.
Signed-off-by: Eunchul Kim <chulspro.kim@samsung.com>
Signed-off-by: Jinyoung Jeon <jy0.jeon@samsung.com>
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-12-14 16:10:31 +07:00
|
|
|
DRM_IOCTL_DEF_DRV(EXYNOS_IPP_GET_PROPERTY,
|
|
|
|
exynos_drm_ipp_get_property, DRM_UNLOCKED | DRM_AUTH),
|
|
|
|
DRM_IOCTL_DEF_DRV(EXYNOS_IPP_SET_PROPERTY,
|
|
|
|
exynos_drm_ipp_set_property, DRM_UNLOCKED | DRM_AUTH),
|
|
|
|
DRM_IOCTL_DEF_DRV(EXYNOS_IPP_QUEUE_BUF,
|
|
|
|
exynos_drm_ipp_queue_buf, DRM_UNLOCKED | DRM_AUTH),
|
|
|
|
DRM_IOCTL_DEF_DRV(EXYNOS_IPP_CMD_CTRL,
|
|
|
|
exynos_drm_ipp_cmd_ctrl, DRM_UNLOCKED | DRM_AUTH),
|
2011-10-04 17:19:01 +07:00
|
|
|
};
|
|
|
|
|
2011-12-08 13:00:20 +07:00
|
|
|
static const struct file_operations exynos_drm_driver_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = drm_open,
|
|
|
|
.mmap = exynos_drm_gem_mmap,
|
|
|
|
.poll = drm_poll,
|
|
|
|
.read = drm_read,
|
|
|
|
.unlocked_ioctl = drm_ioctl,
|
2012-07-10 05:40:07 +07:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
.compat_ioctl = drm_compat_ioctl,
|
|
|
|
#endif
|
2011-12-08 13:00:20 +07:00
|
|
|
.release = drm_release,
|
|
|
|
};
|
|
|
|
|
2011-10-04 17:19:01 +07:00
|
|
|
static struct drm_driver exynos_drm_driver = {
|
2014-04-12 07:39:52 +07:00
|
|
|
.driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME,
|
2011-10-04 17:19:01 +07:00
|
|
|
.load = exynos_drm_load,
|
|
|
|
.unload = exynos_drm_unload,
|
2014-01-31 04:19:27 +07:00
|
|
|
.suspend = exynos_drm_suspend,
|
|
|
|
.resume = exynos_drm_resume,
|
2012-03-16 16:47:09 +07:00
|
|
|
.open = exynos_drm_open,
|
2011-10-14 11:29:51 +07:00
|
|
|
.preclose = exynos_drm_preclose,
|
2011-10-04 17:19:01 +07:00
|
|
|
.lastclose = exynos_drm_lastclose,
|
2012-02-15 09:25:22 +07:00
|
|
|
.postclose = exynos_drm_postclose,
|
2014-08-29 17:12:43 +07:00
|
|
|
.set_busid = drm_platform_set_busid,
|
2011-10-04 17:19:01 +07:00
|
|
|
.get_vblank_counter = drm_vblank_count,
|
|
|
|
.enable_vblank = exynos_drm_crtc_enable_vblank,
|
|
|
|
.disable_vblank = exynos_drm_crtc_disable_vblank,
|
|
|
|
.gem_free_object = exynos_drm_gem_free_object,
|
|
|
|
.gem_vm_ops = &exynos_drm_gem_vm_ops,
|
|
|
|
.dumb_create = exynos_drm_gem_dumb_create,
|
|
|
|
.dumb_map_offset = exynos_drm_gem_dumb_map_offset,
|
2013-07-16 14:12:04 +07:00
|
|
|
.dumb_destroy = drm_gem_dumb_destroy,
|
2012-04-23 19:01:28 +07:00
|
|
|
.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
|
|
|
|
.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
|
|
|
|
.gem_prime_export = exynos_dmabuf_prime_export,
|
|
|
|
.gem_prime_import = exynos_dmabuf_prime_import,
|
2011-10-04 17:19:01 +07:00
|
|
|
.ioctls = exynos_ioctls,
|
2013-08-03 00:27:49 +07:00
|
|
|
.num_ioctls = ARRAY_SIZE(exynos_ioctls),
|
2011-12-08 13:00:20 +07:00
|
|
|
.fops = &exynos_drm_driver_fops,
|
2011-10-04 17:19:01 +07:00
|
|
|
.name = DRIVER_NAME,
|
|
|
|
.desc = DRIVER_DESC,
|
|
|
|
.date = DRIVER_DATE,
|
|
|
|
.major = DRIVER_MAJOR,
|
|
|
|
.minor = DRIVER_MINOR,
|
|
|
|
};
|
|
|
|
|
2014-01-31 04:19:27 +07:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
static int exynos_drm_sys_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
struct drm_device *drm_dev = dev_get_drvdata(dev);
|
|
|
|
pm_message_t message;
|
|
|
|
|
2014-06-30 20:25:44 +07:00
|
|
|
if (pm_runtime_suspended(dev) || !drm_dev)
|
2014-01-31 04:19:27 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
message.event = PM_EVENT_SUSPEND;
|
|
|
|
return exynos_drm_suspend(drm_dev, message);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int exynos_drm_sys_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
struct drm_device *drm_dev = dev_get_drvdata(dev);
|
|
|
|
|
2014-06-30 20:25:44 +07:00
|
|
|
if (pm_runtime_suspended(dev) || !drm_dev)
|
2014-01-31 04:19:27 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
return exynos_drm_resume(drm_dev);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static const struct dev_pm_ops exynos_drm_pm_ops = {
|
|
|
|
SET_SYSTEM_SLEEP_PM_OPS(exynos_drm_sys_suspend, exynos_drm_sys_resume)
|
|
|
|
};
|
|
|
|
|
2014-05-09 12:25:20 +07:00
|
|
|
int exynos_drm_component_add(struct device *dev,
|
2014-05-29 16:28:02 +07:00
|
|
|
enum exynos_drm_device_type dev_type,
|
|
|
|
enum exynos_drm_output_type out_type)
|
2014-05-09 12:25:20 +07:00
|
|
|
{
|
|
|
|
struct component_dev *cdev;
|
2014-05-29 16:28:02 +07:00
|
|
|
|
|
|
|
if (dev_type != EXYNOS_DEVICE_TYPE_CRTC &&
|
|
|
|
dev_type != EXYNOS_DEVICE_TYPE_CONNECTOR) {
|
|
|
|
DRM_ERROR("invalid device type.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_lock(&drm_component_lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure to check if there is a component which has two device
|
|
|
|
* objects, for connector and for encoder/connector.
|
|
|
|
* It should make sure that crtc and encoder/connector drivers are
|
|
|
|
* ready before exynos drm core binds them.
|
|
|
|
*/
|
|
|
|
list_for_each_entry(cdev, &drm_component_list, list) {
|
|
|
|
if (cdev->out_type == out_type) {
|
|
|
|
/*
|
|
|
|
* If crtc and encoder/connector device objects are
|
|
|
|
* added already just return.
|
|
|
|
*/
|
|
|
|
if (cdev->dev_type_flag == (EXYNOS_DEVICE_TYPE_CRTC |
|
|
|
|
EXYNOS_DEVICE_TYPE_CONNECTOR)) {
|
|
|
|
mutex_unlock(&drm_component_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dev_type == EXYNOS_DEVICE_TYPE_CRTC) {
|
|
|
|
cdev->crtc_dev = dev;
|
|
|
|
cdev->dev_type_flag |= dev_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dev_type == EXYNOS_DEVICE_TYPE_CONNECTOR) {
|
|
|
|
cdev->conn_dev = dev;
|
|
|
|
cdev->dev_type_flag |= dev_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&drm_component_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&drm_component_lock);
|
2014-05-09 12:25:20 +07:00
|
|
|
|
|
|
|
cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
|
|
|
|
if (!cdev)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2014-05-29 16:28:02 +07:00
|
|
|
if (dev_type == EXYNOS_DEVICE_TYPE_CRTC)
|
|
|
|
cdev->crtc_dev = dev;
|
|
|
|
if (dev_type == EXYNOS_DEVICE_TYPE_CONNECTOR)
|
|
|
|
cdev->conn_dev = dev;
|
2014-05-09 12:25:20 +07:00
|
|
|
|
2014-05-29 16:28:02 +07:00
|
|
|
cdev->out_type = out_type;
|
|
|
|
cdev->dev_type_flag = dev_type;
|
2014-05-09 12:25:20 +07:00
|
|
|
|
|
|
|
mutex_lock(&drm_component_lock);
|
|
|
|
list_add_tail(&cdev->list, &drm_component_list);
|
|
|
|
mutex_unlock(&drm_component_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void exynos_drm_component_del(struct device *dev,
|
2014-05-29 16:28:02 +07:00
|
|
|
enum exynos_drm_device_type dev_type)
|
2014-05-09 12:25:20 +07:00
|
|
|
{
|
|
|
|
struct component_dev *cdev, *next;
|
|
|
|
|
|
|
|
mutex_lock(&drm_component_lock);
|
|
|
|
|
|
|
|
list_for_each_entry_safe(cdev, next, &drm_component_list, list) {
|
2014-05-29 16:28:02 +07:00
|
|
|
if (dev_type == EXYNOS_DEVICE_TYPE_CRTC) {
|
|
|
|
if (cdev->crtc_dev == dev) {
|
|
|
|
cdev->crtc_dev = NULL;
|
|
|
|
cdev->dev_type_flag &= ~dev_type;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dev_type == EXYNOS_DEVICE_TYPE_CONNECTOR) {
|
|
|
|
if (cdev->conn_dev == dev) {
|
|
|
|
cdev->conn_dev = NULL;
|
|
|
|
cdev->dev_type_flag &= ~dev_type;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Release cdev object only in case that both of crtc and
|
|
|
|
* encoder/connector device objects are NULL.
|
|
|
|
*/
|
|
|
|
if (!cdev->crtc_dev && !cdev->conn_dev) {
|
2014-05-09 12:25:20 +07:00
|
|
|
list_del(&cdev->list);
|
|
|
|
kfree(cdev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&drm_component_lock);
|
|
|
|
}
|
|
|
|
|
2014-09-11 15:04:03 +07:00
|
|
|
static int compare_dev(struct device *dev, void *data)
|
2014-05-09 12:25:20 +07:00
|
|
|
{
|
|
|
|
return dev == (struct device *)data;
|
|
|
|
}
|
|
|
|
|
2014-09-11 15:04:03 +07:00
|
|
|
static struct component_match *exynos_drm_match_add(struct device *dev)
|
2014-05-09 12:25:20 +07:00
|
|
|
{
|
2014-09-11 15:04:03 +07:00
|
|
|
struct component_match *match = NULL;
|
2014-05-09 12:25:20 +07:00
|
|
|
struct component_dev *cdev;
|
2014-05-29 16:28:02 +07:00
|
|
|
unsigned int attach_cnt = 0;
|
2014-05-09 12:25:20 +07:00
|
|
|
|
|
|
|
mutex_lock(&drm_component_lock);
|
|
|
|
|
2014-11-06 21:00:37 +07:00
|
|
|
/* Do not retry to probe if there is no any kms driver regitered. */
|
|
|
|
if (list_empty(&drm_component_list)) {
|
|
|
|
mutex_unlock(&drm_component_lock);
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
}
|
|
|
|
|
2014-05-09 12:25:20 +07:00
|
|
|
list_for_each_entry(cdev, &drm_component_list, list) {
|
2014-05-29 16:28:02 +07:00
|
|
|
/*
|
|
|
|
* Add components to master only in case that crtc and
|
|
|
|
* encoder/connector device objects exist.
|
|
|
|
*/
|
|
|
|
if (!cdev->crtc_dev || !cdev->conn_dev)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
attach_cnt++;
|
|
|
|
|
2014-05-09 12:25:20 +07:00
|
|
|
mutex_unlock(&drm_component_lock);
|
|
|
|
|
2014-05-29 16:28:02 +07:00
|
|
|
/*
|
|
|
|
* fimd and dpi modules have same device object so add
|
|
|
|
* only crtc device object in this case.
|
|
|
|
*/
|
|
|
|
if (cdev->crtc_dev == cdev->conn_dev) {
|
2014-09-11 15:04:03 +07:00
|
|
|
component_match_add(dev, &match, compare_dev,
|
|
|
|
cdev->crtc_dev);
|
2014-05-29 16:28:02 +07:00
|
|
|
goto out_lock;
|
|
|
|
}
|
2014-05-09 12:25:20 +07:00
|
|
|
|
2014-05-29 16:28:02 +07:00
|
|
|
/*
|
|
|
|
* Do not chage below call order.
|
|
|
|
* crtc device first should be added to master because
|
|
|
|
* connector/encoder need pipe number of crtc when they
|
|
|
|
* are created.
|
|
|
|
*/
|
2014-09-11 15:04:03 +07:00
|
|
|
component_match_add(dev, &match, compare_dev, cdev->crtc_dev);
|
|
|
|
component_match_add(dev, &match, compare_dev, cdev->conn_dev);
|
2014-05-29 16:28:02 +07:00
|
|
|
|
|
|
|
out_lock:
|
2014-05-09 12:25:20 +07:00
|
|
|
mutex_lock(&drm_component_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&drm_component_lock);
|
|
|
|
|
2014-09-11 15:04:03 +07:00
|
|
|
return attach_cnt ? match : ERR_PTR(-EPROBE_DEFER);
|
2014-05-09 12:25:20 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int exynos_drm_bind(struct device *dev)
|
|
|
|
{
|
|
|
|
return drm_platform_init(&exynos_drm_driver, to_platform_device(dev));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void exynos_drm_unbind(struct device *dev)
|
|
|
|
{
|
|
|
|
drm_put_dev(dev_get_drvdata(dev));
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct component_master_ops exynos_drm_ops = {
|
|
|
|
.bind = exynos_drm_bind,
|
|
|
|
.unbind = exynos_drm_unbind,
|
2011-10-04 17:19:01 +07:00
|
|
|
};
|
|
|
|
|
2014-11-13 14:37:57 +07:00
|
|
|
static struct platform_driver *const exynos_drm_kms_drivers[] = {
|
2014-05-09 12:25:20 +07:00
|
|
|
#ifdef CONFIG_DRM_EXYNOS_FIMD
|
2014-11-13 14:37:57 +07:00
|
|
|
&fimd_driver,
|
2014-05-09 12:25:20 +07:00
|
|
|
#endif
|
2015-02-05 22:54:04 +07:00
|
|
|
#ifdef CONFIG_DRM_EXYNOS7_DECON
|
|
|
|
&decon_driver,
|
|
|
|
#endif
|
2014-01-31 04:19:23 +07:00
|
|
|
#ifdef CONFIG_DRM_EXYNOS_DP
|
2014-11-13 14:37:57 +07:00
|
|
|
&dp_driver,
|
2014-01-31 04:19:23 +07:00
|
|
|
#endif
|
2014-04-03 23:19:56 +07:00
|
|
|
#ifdef CONFIG_DRM_EXYNOS_DSI
|
2014-11-13 14:37:57 +07:00
|
|
|
&dsi_driver,
|
2014-04-03 23:19:56 +07:00
|
|
|
#endif
|
2012-03-16 16:47:08 +07:00
|
|
|
#ifdef CONFIG_DRM_EXYNOS_HDMI
|
2014-11-13 14:37:57 +07:00
|
|
|
&mixer_driver,
|
|
|
|
&hdmi_driver,
|
2012-03-21 08:55:26 +07:00
|
|
|
#endif
|
2014-11-13 14:37:57 +07:00
|
|
|
};
|
2012-03-21 08:55:26 +07:00
|
|
|
|
2014-11-13 14:37:57 +07:00
|
|
|
static struct platform_driver *const exynos_drm_non_kms_drivers[] = {
|
2012-05-17 18:06:32 +07:00
|
|
|
#ifdef CONFIG_DRM_EXYNOS_G2D
|
2014-11-13 14:37:57 +07:00
|
|
|
&g2d_driver,
|
2012-05-17 18:06:32 +07:00
|
|
|
#endif
|
2012-12-14 15:58:55 +07:00
|
|
|
#ifdef CONFIG_DRM_EXYNOS_FIMC
|
2014-11-13 14:37:57 +07:00
|
|
|
&fimc_driver,
|
2012-12-14 15:58:55 +07:00
|
|
|
#endif
|
2012-12-14 15:58:56 +07:00
|
|
|
#ifdef CONFIG_DRM_EXYNOS_ROTATOR
|
2014-11-13 14:37:57 +07:00
|
|
|
&rotator_driver,
|
2012-12-14 15:58:56 +07:00
|
|
|
#endif
|
2012-12-14 15:58:57 +07:00
|
|
|
#ifdef CONFIG_DRM_EXYNOS_GSC
|
2014-11-13 14:37:57 +07:00
|
|
|
&gsc_driver,
|
drm/exynos: add ipp subsystem
This patch adds Image Post Processing(IPP) support for exynos drm driver.
IPP supports image scaler/rotator and input/output DMA operations
using IPP subsystem framework to control FIMC, Rotator and GSC hardware
and supports some user interfaces for user side.
And each IPP-based drivers support Memory to Memory operations
with various converting. And in case of FIMC hardware, it also supports
Writeback and Display output operations through local path.
Features:
- Memory to Memory operation support.
- Various pixel formats support.
- Image scaling support.
- Color Space Conversion support.
- Image crop operation support.
- Rotate operation support to 90, 180 or 270 degree.
- Flip operation support to vertical, horizontal or both.
- Writeback operation support to display blended image of FIMD fifo on screen
A summary to IPP Subsystem operations:
First of all, user should get property capabilities from IPP subsystem
and set these properties to hardware registers for desired operations.
The properties could be pixel format, position, rotation degree and
flip operation.
And next, user should set source and destination buffer data using
DRM_EXYNOS_IPP_QUEUE_BUF ioctl command with gem handles to source and
destinition buffers.
And next, user can control user-desired hardware with desired operations
such as play, stop, pause and resume controls.
And finally, user can aware of dma operation completion and also get
destination buffer that it contains user-desried result through dequeue
command.
IOCTL commands:
- DRM_EXYNOS_IPP_GET_PROPERTY
. get ipp driver capabilitis and id.
- DRM_EXYNOS_IPP_SET_PROPERTY
. set format, position, rotation, flip to source and destination buffers
- DRM_EXYNOS_IPP_QUEUE_BUF
. enqueue/dequeue buffer and make event list.
- DRM_EXYNOS_IPP_CMD_CTRL
. play/stop/pause/resume control.
Event:
- DRM_EXYNOS_IPP_EVENT
. a event to notify dma operation completion to user side.
Basic control flow:
Open -> Get properties -> User choose desired IPP sub driver(FIMC, Rotator
or GSCALER) -> Set Property -> Create gem handle -> Enqueue to source and
destination buffers -> Command control(Play) -> Event is notified to User
-> User gets destinition buffer complated -> (Enqueue to source and
destination buffers -> Event is notified to User) * N -> Queue/Dequeue to
source and destination buffers -> Command control(Stop) -> Free gem handle
-> Close
Changelog v1 ~ v5:
- added comments, code fixups and cleanups.
Signed-off-by: Eunchul Kim <chulspro.kim@samsung.com>
Signed-off-by: Jinyoung Jeon <jy0.jeon@samsung.com>
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-12-14 16:10:31 +07:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_DRM_EXYNOS_IPP
|
2014-11-13 14:37:57 +07:00
|
|
|
&ipp_driver,
|
2012-12-14 15:58:57 +07:00
|
|
|
#endif
|
2014-11-13 14:37:57 +07:00
|
|
|
};
|
2012-12-14 15:58:57 +07:00
|
|
|
|
2014-11-13 14:37:57 +07:00
|
|
|
static int exynos_drm_platform_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct component_match *match;
|
2014-03-17 17:27:17 +07:00
|
|
|
|
2014-11-13 14:37:57 +07:00
|
|
|
pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
|
|
|
|
exynos_drm_driver.num_ioctls = ARRAY_SIZE(exynos_ioctls);
|
2014-04-03 23:19:56 +07:00
|
|
|
|
2014-11-13 14:37:57 +07:00
|
|
|
match = exynos_drm_match_add(&pdev->dev);
|
|
|
|
if (IS_ERR(match)) {
|
drm/exynos: move Exynos platform drivers registration to init
Registering the Exynos DRM subdevices platform drivers in the probe
function is causing an infinite loop. Fix this by moving it to the
exynos_drm_init() function to register the drivers on module init.
Registering drivers in the probe functions causes a deadlock in the parent
device lock. See Grant Likely explanation on the topic:
"I think the problem is that exynos_drm_init() is registering a normal
(non-OF) platform device, so the parent will be /sys/devices/platform.
It immediately gets bound against exynos_drm_platform_driver which
calls the exynos drm_platform_probe() hook. The driver core obtains
device_lock() on the device *and on the device parent*.
Inside the probe hook, additional platform_drivers get registered.
Each time one does, it tries to bind against every platform device in
the system, which includes the ones created by OF. When it attempts to
bind, it obtains device_lock() on the device *and on the device
parent*.
Before the change to move of-generated platform devices into
/sys/devices/platform, the devices had different parents. Now both
devices have /sys/devices/platform as the parent, so yes they are
going to deadlock.
The real problem is registering drivers from within a probe hook. That
is completely wrong for the above deadlock reason. __driver_attach()
will deadlock. Those registrations must be pulled out of .probe().
Registering devices in .probe() is okay because __device_attach()
doesn't try to obtain device_lock() on the parent."
INFO: task swapper/0:1 blocked for more than 120 seconds.
Not tainted 3.18.0-rc3-next-20141105 #794
"echo 0 > /proc/sys/kernel/hung_task_timeout_secs" disables this message.
swapper/0 D c052534c 0 1 0 0x00000000
[<c052534c>] (__schedule) from [<c0525b34>] (schedule_preempt_disabled+0x14/0x20)
[<c0525b34>] (schedule_preempt_disabled) from [<c0526d44>] (mutex_lock_nested+0x1c4/0x464
[<c0526d44>] (mutex_lock_nested) from [<c02be908>] (__driver_attach+0x48/0x98)
[<c02be908>] (__driver_attach) from [<c02bcc00>] (bus_for_each_dev+0x54/0x88)
[<c02bcc00>] (bus_for_each_dev) from [<c02bdce0>] (bus_add_driver+0xe4/0x200)
[<c02bdce0>] (bus_add_driver) from [<c02bef94>] (driver_register+0x78/0xf4)
[<c02bef94>] (driver_register) from [<c029e99c>] (exynos_drm_platform_probe+0x34/0x234)
[<c029e99c>] (exynos_drm_platform_probe) from [<c02bfcf0>] (platform_drv_probe+0x48/0xa4)
[<c02bfcf0>] (platform_drv_probe) from [<c02be680>] (driver_probe_device+0x13c/0x37c)
[<c02be680>] (driver_probe_device) from [<c02be954>] (__driver_attach+0x94/0x98)
[<c02be954>] (__driver_attach) from [<c02bcc00>] (bus_for_each_dev+0x54/0x88)
[<c02bcc00>] (bus_for_each_dev) from [<c02bdce0>] (bus_add_driver+0xe4/0x200)
[<c02bdce0>] (bus_add_driver) from [<c02bef94>] (driver_register+0x78/0xf4)
[<c02bef94>] (driver_register) from [<c029e938>] (exynos_drm_init+0x70/0xa0)
[<c029e938>] (exynos_drm_init) from [<c00089b0>] (do_one_initcall+0xac/0x1f0)
[<c00089b0>] (do_one_initcall) from [<c074bd90>] (kernel_init_freeable+0x10c/0x1d8)
[<c074bd90>] (kernel_init_freeable) from [<c051eabc>] (kernel_init+0x8/0xec)
[<c051eabc>] (kernel_init) from [<c000f268>] (ret_from_fork+0x14/0x2c)
3 locks held by swapper/0/1:
#0: (&dev->mutex){......}, at: [<c02be908>] __driver_attach+0x48/0x98
#1: (&dev->mutex){......}, at: [<c02be918>] __driver_attach+0x58/0x98
#2: (&dev->mutex){......}, at: [<c02be908>] __driver_attach+0x48/0x98
Changelog v2:
- call platform_driver_register after all kms and non kms drivers are
registered
- rebased it to exynos-drm-next
Signed-off-by: Javier Martinez Canillas <javier.martinez@collabora.co.uk>
Signed-off-by: Gustavo Padovan <gustavo.padovan@collabora.co.uk>
Signed-off-by: Inki Dae <inki.dae@samsung.com>
2014-11-24 14:37:26 +07:00
|
|
|
return PTR_ERR(match);
|
2014-11-13 14:37:57 +07:00
|
|
|
}
|
2014-05-09 12:25:20 +07:00
|
|
|
|
drm/exynos: move Exynos platform drivers registration to init
Registering the Exynos DRM subdevices platform drivers in the probe
function is causing an infinite loop. Fix this by moving it to the
exynos_drm_init() function to register the drivers on module init.
Registering drivers in the probe functions causes a deadlock in the parent
device lock. See Grant Likely explanation on the topic:
"I think the problem is that exynos_drm_init() is registering a normal
(non-OF) platform device, so the parent will be /sys/devices/platform.
It immediately gets bound against exynos_drm_platform_driver which
calls the exynos drm_platform_probe() hook. The driver core obtains
device_lock() on the device *and on the device parent*.
Inside the probe hook, additional platform_drivers get registered.
Each time one does, it tries to bind against every platform device in
the system, which includes the ones created by OF. When it attempts to
bind, it obtains device_lock() on the device *and on the device
parent*.
Before the change to move of-generated platform devices into
/sys/devices/platform, the devices had different parents. Now both
devices have /sys/devices/platform as the parent, so yes they are
going to deadlock.
The real problem is registering drivers from within a probe hook. That
is completely wrong for the above deadlock reason. __driver_attach()
will deadlock. Those registrations must be pulled out of .probe().
Registering devices in .probe() is okay because __device_attach()
doesn't try to obtain device_lock() on the parent."
INFO: task swapper/0:1 blocked for more than 120 seconds.
Not tainted 3.18.0-rc3-next-20141105 #794
"echo 0 > /proc/sys/kernel/hung_task_timeout_secs" disables this message.
swapper/0 D c052534c 0 1 0 0x00000000
[<c052534c>] (__schedule) from [<c0525b34>] (schedule_preempt_disabled+0x14/0x20)
[<c0525b34>] (schedule_preempt_disabled) from [<c0526d44>] (mutex_lock_nested+0x1c4/0x464
[<c0526d44>] (mutex_lock_nested) from [<c02be908>] (__driver_attach+0x48/0x98)
[<c02be908>] (__driver_attach) from [<c02bcc00>] (bus_for_each_dev+0x54/0x88)
[<c02bcc00>] (bus_for_each_dev) from [<c02bdce0>] (bus_add_driver+0xe4/0x200)
[<c02bdce0>] (bus_add_driver) from [<c02bef94>] (driver_register+0x78/0xf4)
[<c02bef94>] (driver_register) from [<c029e99c>] (exynos_drm_platform_probe+0x34/0x234)
[<c029e99c>] (exynos_drm_platform_probe) from [<c02bfcf0>] (platform_drv_probe+0x48/0xa4)
[<c02bfcf0>] (platform_drv_probe) from [<c02be680>] (driver_probe_device+0x13c/0x37c)
[<c02be680>] (driver_probe_device) from [<c02be954>] (__driver_attach+0x94/0x98)
[<c02be954>] (__driver_attach) from [<c02bcc00>] (bus_for_each_dev+0x54/0x88)
[<c02bcc00>] (bus_for_each_dev) from [<c02bdce0>] (bus_add_driver+0xe4/0x200)
[<c02bdce0>] (bus_add_driver) from [<c02bef94>] (driver_register+0x78/0xf4)
[<c02bef94>] (driver_register) from [<c029e938>] (exynos_drm_init+0x70/0xa0)
[<c029e938>] (exynos_drm_init) from [<c00089b0>] (do_one_initcall+0xac/0x1f0)
[<c00089b0>] (do_one_initcall) from [<c074bd90>] (kernel_init_freeable+0x10c/0x1d8)
[<c074bd90>] (kernel_init_freeable) from [<c051eabc>] (kernel_init+0x8/0xec)
[<c051eabc>] (kernel_init) from [<c000f268>] (ret_from_fork+0x14/0x2c)
3 locks held by swapper/0/1:
#0: (&dev->mutex){......}, at: [<c02be908>] __driver_attach+0x48/0x98
#1: (&dev->mutex){......}, at: [<c02be918>] __driver_attach+0x58/0x98
#2: (&dev->mutex){......}, at: [<c02be908>] __driver_attach+0x48/0x98
Changelog v2:
- call platform_driver_register after all kms and non kms drivers are
registered
- rebased it to exynos-drm-next
Signed-off-by: Javier Martinez Canillas <javier.martinez@collabora.co.uk>
Signed-off-by: Gustavo Padovan <gustavo.padovan@collabora.co.uk>
Signed-off-by: Inki Dae <inki.dae@samsung.com>
2014-11-24 14:37:26 +07:00
|
|
|
return component_master_add_with_match(&pdev->dev, &exynos_drm_ops,
|
|
|
|
match);
|
2011-10-04 17:19:01 +07:00
|
|
|
}
|
|
|
|
|
2014-05-09 12:25:20 +07:00
|
|
|
static int exynos_drm_platform_remove(struct platform_device *pdev)
|
2011-10-04 17:19:01 +07:00
|
|
|
{
|
2014-05-09 12:25:20 +07:00
|
|
|
component_master_del(&pdev->dev, &exynos_drm_ops);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-11-24 15:08:00 +07:00
|
|
|
static const char * const strings[] = {
|
|
|
|
"samsung,exynos3",
|
|
|
|
"samsung,exynos4",
|
|
|
|
"samsung,exynos5",
|
2015-02-05 22:54:04 +07:00
|
|
|
"samsung,exynos7",
|
2014-11-24 15:08:00 +07:00
|
|
|
};
|
|
|
|
|
2014-05-09 12:25:20 +07:00
|
|
|
static struct platform_driver exynos_drm_platform_driver = {
|
|
|
|
.probe = exynos_drm_platform_probe,
|
|
|
|
.remove = exynos_drm_platform_remove,
|
|
|
|
.driver = {
|
|
|
|
.name = "exynos-drm",
|
|
|
|
.pm = &exynos_drm_pm_ops,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static int exynos_drm_init(void)
|
|
|
|
{
|
2014-11-24 15:08:00 +07:00
|
|
|
bool is_exynos = false;
|
drm/exynos: move Exynos platform drivers registration to init
Registering the Exynos DRM subdevices platform drivers in the probe
function is causing an infinite loop. Fix this by moving it to the
exynos_drm_init() function to register the drivers on module init.
Registering drivers in the probe functions causes a deadlock in the parent
device lock. See Grant Likely explanation on the topic:
"I think the problem is that exynos_drm_init() is registering a normal
(non-OF) platform device, so the parent will be /sys/devices/platform.
It immediately gets bound against exynos_drm_platform_driver which
calls the exynos drm_platform_probe() hook. The driver core obtains
device_lock() on the device *and on the device parent*.
Inside the probe hook, additional platform_drivers get registered.
Each time one does, it tries to bind against every platform device in
the system, which includes the ones created by OF. When it attempts to
bind, it obtains device_lock() on the device *and on the device
parent*.
Before the change to move of-generated platform devices into
/sys/devices/platform, the devices had different parents. Now both
devices have /sys/devices/platform as the parent, so yes they are
going to deadlock.
The real problem is registering drivers from within a probe hook. That
is completely wrong for the above deadlock reason. __driver_attach()
will deadlock. Those registrations must be pulled out of .probe().
Registering devices in .probe() is okay because __device_attach()
doesn't try to obtain device_lock() on the parent."
INFO: task swapper/0:1 blocked for more than 120 seconds.
Not tainted 3.18.0-rc3-next-20141105 #794
"echo 0 > /proc/sys/kernel/hung_task_timeout_secs" disables this message.
swapper/0 D c052534c 0 1 0 0x00000000
[<c052534c>] (__schedule) from [<c0525b34>] (schedule_preempt_disabled+0x14/0x20)
[<c0525b34>] (schedule_preempt_disabled) from [<c0526d44>] (mutex_lock_nested+0x1c4/0x464
[<c0526d44>] (mutex_lock_nested) from [<c02be908>] (__driver_attach+0x48/0x98)
[<c02be908>] (__driver_attach) from [<c02bcc00>] (bus_for_each_dev+0x54/0x88)
[<c02bcc00>] (bus_for_each_dev) from [<c02bdce0>] (bus_add_driver+0xe4/0x200)
[<c02bdce0>] (bus_add_driver) from [<c02bef94>] (driver_register+0x78/0xf4)
[<c02bef94>] (driver_register) from [<c029e99c>] (exynos_drm_platform_probe+0x34/0x234)
[<c029e99c>] (exynos_drm_platform_probe) from [<c02bfcf0>] (platform_drv_probe+0x48/0xa4)
[<c02bfcf0>] (platform_drv_probe) from [<c02be680>] (driver_probe_device+0x13c/0x37c)
[<c02be680>] (driver_probe_device) from [<c02be954>] (__driver_attach+0x94/0x98)
[<c02be954>] (__driver_attach) from [<c02bcc00>] (bus_for_each_dev+0x54/0x88)
[<c02bcc00>] (bus_for_each_dev) from [<c02bdce0>] (bus_add_driver+0xe4/0x200)
[<c02bdce0>] (bus_add_driver) from [<c02bef94>] (driver_register+0x78/0xf4)
[<c02bef94>] (driver_register) from [<c029e938>] (exynos_drm_init+0x70/0xa0)
[<c029e938>] (exynos_drm_init) from [<c00089b0>] (do_one_initcall+0xac/0x1f0)
[<c00089b0>] (do_one_initcall) from [<c074bd90>] (kernel_init_freeable+0x10c/0x1d8)
[<c074bd90>] (kernel_init_freeable) from [<c051eabc>] (kernel_init+0x8/0xec)
[<c051eabc>] (kernel_init) from [<c000f268>] (ret_from_fork+0x14/0x2c)
3 locks held by swapper/0/1:
#0: (&dev->mutex){......}, at: [<c02be908>] __driver_attach+0x48/0x98
#1: (&dev->mutex){......}, at: [<c02be918>] __driver_attach+0x58/0x98
#2: (&dev->mutex){......}, at: [<c02be908>] __driver_attach+0x48/0x98
Changelog v2:
- call platform_driver_register after all kms and non kms drivers are
registered
- rebased it to exynos-drm-next
Signed-off-by: Javier Martinez Canillas <javier.martinez@collabora.co.uk>
Signed-off-by: Gustavo Padovan <gustavo.padovan@collabora.co.uk>
Signed-off-by: Inki Dae <inki.dae@samsung.com>
2014-11-24 14:37:26 +07:00
|
|
|
int ret, i, j;
|
2014-05-09 12:25:20 +07:00
|
|
|
|
2014-11-06 17:23:35 +07:00
|
|
|
/*
|
|
|
|
* Register device object only in case of Exynos SoC.
|
|
|
|
*
|
|
|
|
* Below codes resolves temporarily infinite loop issue incurred
|
|
|
|
* by Exynos drm driver when using multi-platform kernel.
|
|
|
|
* So these codes will be replaced with more generic way later.
|
|
|
|
*/
|
2014-11-24 15:08:00 +07:00
|
|
|
for (i = 0; i < ARRAY_SIZE(strings); i++) {
|
|
|
|
if (of_machine_is_compatible(strings[i])) {
|
|
|
|
is_exynos = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!is_exynos)
|
2014-11-06 17:23:35 +07:00
|
|
|
return -ENODEV;
|
2014-05-09 12:25:20 +07:00
|
|
|
|
|
|
|
exynos_drm_pdev = platform_device_register_simple("exynos-drm", -1,
|
|
|
|
NULL, 0);
|
|
|
|
if (IS_ERR(exynos_drm_pdev))
|
|
|
|
return PTR_ERR(exynos_drm_pdev);
|
|
|
|
|
|
|
|
ret = exynos_drm_probe_vidi();
|
|
|
|
if (ret < 0)
|
|
|
|
goto err_unregister_pd;
|
|
|
|
|
drm/exynos: move Exynos platform drivers registration to init
Registering the Exynos DRM subdevices platform drivers in the probe
function is causing an infinite loop. Fix this by moving it to the
exynos_drm_init() function to register the drivers on module init.
Registering drivers in the probe functions causes a deadlock in the parent
device lock. See Grant Likely explanation on the topic:
"I think the problem is that exynos_drm_init() is registering a normal
(non-OF) platform device, so the parent will be /sys/devices/platform.
It immediately gets bound against exynos_drm_platform_driver which
calls the exynos drm_platform_probe() hook. The driver core obtains
device_lock() on the device *and on the device parent*.
Inside the probe hook, additional platform_drivers get registered.
Each time one does, it tries to bind against every platform device in
the system, which includes the ones created by OF. When it attempts to
bind, it obtains device_lock() on the device *and on the device
parent*.
Before the change to move of-generated platform devices into
/sys/devices/platform, the devices had different parents. Now both
devices have /sys/devices/platform as the parent, so yes they are
going to deadlock.
The real problem is registering drivers from within a probe hook. That
is completely wrong for the above deadlock reason. __driver_attach()
will deadlock. Those registrations must be pulled out of .probe().
Registering devices in .probe() is okay because __device_attach()
doesn't try to obtain device_lock() on the parent."
INFO: task swapper/0:1 blocked for more than 120 seconds.
Not tainted 3.18.0-rc3-next-20141105 #794
"echo 0 > /proc/sys/kernel/hung_task_timeout_secs" disables this message.
swapper/0 D c052534c 0 1 0 0x00000000
[<c052534c>] (__schedule) from [<c0525b34>] (schedule_preempt_disabled+0x14/0x20)
[<c0525b34>] (schedule_preempt_disabled) from [<c0526d44>] (mutex_lock_nested+0x1c4/0x464
[<c0526d44>] (mutex_lock_nested) from [<c02be908>] (__driver_attach+0x48/0x98)
[<c02be908>] (__driver_attach) from [<c02bcc00>] (bus_for_each_dev+0x54/0x88)
[<c02bcc00>] (bus_for_each_dev) from [<c02bdce0>] (bus_add_driver+0xe4/0x200)
[<c02bdce0>] (bus_add_driver) from [<c02bef94>] (driver_register+0x78/0xf4)
[<c02bef94>] (driver_register) from [<c029e99c>] (exynos_drm_platform_probe+0x34/0x234)
[<c029e99c>] (exynos_drm_platform_probe) from [<c02bfcf0>] (platform_drv_probe+0x48/0xa4)
[<c02bfcf0>] (platform_drv_probe) from [<c02be680>] (driver_probe_device+0x13c/0x37c)
[<c02be680>] (driver_probe_device) from [<c02be954>] (__driver_attach+0x94/0x98)
[<c02be954>] (__driver_attach) from [<c02bcc00>] (bus_for_each_dev+0x54/0x88)
[<c02bcc00>] (bus_for_each_dev) from [<c02bdce0>] (bus_add_driver+0xe4/0x200)
[<c02bdce0>] (bus_add_driver) from [<c02bef94>] (driver_register+0x78/0xf4)
[<c02bef94>] (driver_register) from [<c029e938>] (exynos_drm_init+0x70/0xa0)
[<c029e938>] (exynos_drm_init) from [<c00089b0>] (do_one_initcall+0xac/0x1f0)
[<c00089b0>] (do_one_initcall) from [<c074bd90>] (kernel_init_freeable+0x10c/0x1d8)
[<c074bd90>] (kernel_init_freeable) from [<c051eabc>] (kernel_init+0x8/0xec)
[<c051eabc>] (kernel_init) from [<c000f268>] (ret_from_fork+0x14/0x2c)
3 locks held by swapper/0/1:
#0: (&dev->mutex){......}, at: [<c02be908>] __driver_attach+0x48/0x98
#1: (&dev->mutex){......}, at: [<c02be918>] __driver_attach+0x58/0x98
#2: (&dev->mutex){......}, at: [<c02be908>] __driver_attach+0x48/0x98
Changelog v2:
- call platform_driver_register after all kms and non kms drivers are
registered
- rebased it to exynos-drm-next
Signed-off-by: Javier Martinez Canillas <javier.martinez@collabora.co.uk>
Signed-off-by: Gustavo Padovan <gustavo.padovan@collabora.co.uk>
Signed-off-by: Inki Dae <inki.dae@samsung.com>
2014-11-24 14:37:26 +07:00
|
|
|
for (i = 0; i < ARRAY_SIZE(exynos_drm_kms_drivers); ++i) {
|
|
|
|
ret = platform_driver_register(exynos_drm_kms_drivers[i]);
|
|
|
|
if (ret < 0)
|
|
|
|
goto err_unregister_kms_drivers;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (j = 0; j < ARRAY_SIZE(exynos_drm_non_kms_drivers); ++j) {
|
|
|
|
ret = platform_driver_register(exynos_drm_non_kms_drivers[j]);
|
|
|
|
if (ret < 0)
|
|
|
|
goto err_unregister_non_kms_drivers;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_DRM_EXYNOS_IPP
|
|
|
|
ret = exynos_platform_device_ipp_register();
|
|
|
|
if (ret < 0)
|
|
|
|
goto err_unregister_non_kms_drivers;
|
2014-05-09 12:25:20 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
ret = platform_driver_register(&exynos_drm_platform_driver);
|
|
|
|
if (ret)
|
drm/exynos: move Exynos platform drivers registration to init
Registering the Exynos DRM subdevices platform drivers in the probe
function is causing an infinite loop. Fix this by moving it to the
exynos_drm_init() function to register the drivers on module init.
Registering drivers in the probe functions causes a deadlock in the parent
device lock. See Grant Likely explanation on the topic:
"I think the problem is that exynos_drm_init() is registering a normal
(non-OF) platform device, so the parent will be /sys/devices/platform.
It immediately gets bound against exynos_drm_platform_driver which
calls the exynos drm_platform_probe() hook. The driver core obtains
device_lock() on the device *and on the device parent*.
Inside the probe hook, additional platform_drivers get registered.
Each time one does, it tries to bind against every platform device in
the system, which includes the ones created by OF. When it attempts to
bind, it obtains device_lock() on the device *and on the device
parent*.
Before the change to move of-generated platform devices into
/sys/devices/platform, the devices had different parents. Now both
devices have /sys/devices/platform as the parent, so yes they are
going to deadlock.
The real problem is registering drivers from within a probe hook. That
is completely wrong for the above deadlock reason. __driver_attach()
will deadlock. Those registrations must be pulled out of .probe().
Registering devices in .probe() is okay because __device_attach()
doesn't try to obtain device_lock() on the parent."
INFO: task swapper/0:1 blocked for more than 120 seconds.
Not tainted 3.18.0-rc3-next-20141105 #794
"echo 0 > /proc/sys/kernel/hung_task_timeout_secs" disables this message.
swapper/0 D c052534c 0 1 0 0x00000000
[<c052534c>] (__schedule) from [<c0525b34>] (schedule_preempt_disabled+0x14/0x20)
[<c0525b34>] (schedule_preempt_disabled) from [<c0526d44>] (mutex_lock_nested+0x1c4/0x464
[<c0526d44>] (mutex_lock_nested) from [<c02be908>] (__driver_attach+0x48/0x98)
[<c02be908>] (__driver_attach) from [<c02bcc00>] (bus_for_each_dev+0x54/0x88)
[<c02bcc00>] (bus_for_each_dev) from [<c02bdce0>] (bus_add_driver+0xe4/0x200)
[<c02bdce0>] (bus_add_driver) from [<c02bef94>] (driver_register+0x78/0xf4)
[<c02bef94>] (driver_register) from [<c029e99c>] (exynos_drm_platform_probe+0x34/0x234)
[<c029e99c>] (exynos_drm_platform_probe) from [<c02bfcf0>] (platform_drv_probe+0x48/0xa4)
[<c02bfcf0>] (platform_drv_probe) from [<c02be680>] (driver_probe_device+0x13c/0x37c)
[<c02be680>] (driver_probe_device) from [<c02be954>] (__driver_attach+0x94/0x98)
[<c02be954>] (__driver_attach) from [<c02bcc00>] (bus_for_each_dev+0x54/0x88)
[<c02bcc00>] (bus_for_each_dev) from [<c02bdce0>] (bus_add_driver+0xe4/0x200)
[<c02bdce0>] (bus_add_driver) from [<c02bef94>] (driver_register+0x78/0xf4)
[<c02bef94>] (driver_register) from [<c029e938>] (exynos_drm_init+0x70/0xa0)
[<c029e938>] (exynos_drm_init) from [<c00089b0>] (do_one_initcall+0xac/0x1f0)
[<c00089b0>] (do_one_initcall) from [<c074bd90>] (kernel_init_freeable+0x10c/0x1d8)
[<c074bd90>] (kernel_init_freeable) from [<c051eabc>] (kernel_init+0x8/0xec)
[<c051eabc>] (kernel_init) from [<c000f268>] (ret_from_fork+0x14/0x2c)
3 locks held by swapper/0/1:
#0: (&dev->mutex){......}, at: [<c02be908>] __driver_attach+0x48/0x98
#1: (&dev->mutex){......}, at: [<c02be918>] __driver_attach+0x58/0x98
#2: (&dev->mutex){......}, at: [<c02be908>] __driver_attach+0x48/0x98
Changelog v2:
- call platform_driver_register after all kms and non kms drivers are
registered
- rebased it to exynos-drm-next
Signed-off-by: Javier Martinez Canillas <javier.martinez@collabora.co.uk>
Signed-off-by: Gustavo Padovan <gustavo.padovan@collabora.co.uk>
Signed-off-by: Inki Dae <inki.dae@samsung.com>
2014-11-24 14:37:26 +07:00
|
|
|
goto err_unregister_resources;
|
2014-05-09 12:25:20 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
drm/exynos: move Exynos platform drivers registration to init
Registering the Exynos DRM subdevices platform drivers in the probe
function is causing an infinite loop. Fix this by moving it to the
exynos_drm_init() function to register the drivers on module init.
Registering drivers in the probe functions causes a deadlock in the parent
device lock. See Grant Likely explanation on the topic:
"I think the problem is that exynos_drm_init() is registering a normal
(non-OF) platform device, so the parent will be /sys/devices/platform.
It immediately gets bound against exynos_drm_platform_driver which
calls the exynos drm_platform_probe() hook. The driver core obtains
device_lock() on the device *and on the device parent*.
Inside the probe hook, additional platform_drivers get registered.
Each time one does, it tries to bind against every platform device in
the system, which includes the ones created by OF. When it attempts to
bind, it obtains device_lock() on the device *and on the device
parent*.
Before the change to move of-generated platform devices into
/sys/devices/platform, the devices had different parents. Now both
devices have /sys/devices/platform as the parent, so yes they are
going to deadlock.
The real problem is registering drivers from within a probe hook. That
is completely wrong for the above deadlock reason. __driver_attach()
will deadlock. Those registrations must be pulled out of .probe().
Registering devices in .probe() is okay because __device_attach()
doesn't try to obtain device_lock() on the parent."
INFO: task swapper/0:1 blocked for more than 120 seconds.
Not tainted 3.18.0-rc3-next-20141105 #794
"echo 0 > /proc/sys/kernel/hung_task_timeout_secs" disables this message.
swapper/0 D c052534c 0 1 0 0x00000000
[<c052534c>] (__schedule) from [<c0525b34>] (schedule_preempt_disabled+0x14/0x20)
[<c0525b34>] (schedule_preempt_disabled) from [<c0526d44>] (mutex_lock_nested+0x1c4/0x464
[<c0526d44>] (mutex_lock_nested) from [<c02be908>] (__driver_attach+0x48/0x98)
[<c02be908>] (__driver_attach) from [<c02bcc00>] (bus_for_each_dev+0x54/0x88)
[<c02bcc00>] (bus_for_each_dev) from [<c02bdce0>] (bus_add_driver+0xe4/0x200)
[<c02bdce0>] (bus_add_driver) from [<c02bef94>] (driver_register+0x78/0xf4)
[<c02bef94>] (driver_register) from [<c029e99c>] (exynos_drm_platform_probe+0x34/0x234)
[<c029e99c>] (exynos_drm_platform_probe) from [<c02bfcf0>] (platform_drv_probe+0x48/0xa4)
[<c02bfcf0>] (platform_drv_probe) from [<c02be680>] (driver_probe_device+0x13c/0x37c)
[<c02be680>] (driver_probe_device) from [<c02be954>] (__driver_attach+0x94/0x98)
[<c02be954>] (__driver_attach) from [<c02bcc00>] (bus_for_each_dev+0x54/0x88)
[<c02bcc00>] (bus_for_each_dev) from [<c02bdce0>] (bus_add_driver+0xe4/0x200)
[<c02bdce0>] (bus_add_driver) from [<c02bef94>] (driver_register+0x78/0xf4)
[<c02bef94>] (driver_register) from [<c029e938>] (exynos_drm_init+0x70/0xa0)
[<c029e938>] (exynos_drm_init) from [<c00089b0>] (do_one_initcall+0xac/0x1f0)
[<c00089b0>] (do_one_initcall) from [<c074bd90>] (kernel_init_freeable+0x10c/0x1d8)
[<c074bd90>] (kernel_init_freeable) from [<c051eabc>] (kernel_init+0x8/0xec)
[<c051eabc>] (kernel_init) from [<c000f268>] (ret_from_fork+0x14/0x2c)
3 locks held by swapper/0/1:
#0: (&dev->mutex){......}, at: [<c02be908>] __driver_attach+0x48/0x98
#1: (&dev->mutex){......}, at: [<c02be918>] __driver_attach+0x58/0x98
#2: (&dev->mutex){......}, at: [<c02be908>] __driver_attach+0x48/0x98
Changelog v2:
- call platform_driver_register after all kms and non kms drivers are
registered
- rebased it to exynos-drm-next
Signed-off-by: Javier Martinez Canillas <javier.martinez@collabora.co.uk>
Signed-off-by: Gustavo Padovan <gustavo.padovan@collabora.co.uk>
Signed-off-by: Inki Dae <inki.dae@samsung.com>
2014-11-24 14:37:26 +07:00
|
|
|
err_unregister_resources:
|
|
|
|
#ifdef CONFIG_DRM_EXYNOS_IPP
|
|
|
|
exynos_platform_device_ipp_unregister();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
err_unregister_non_kms_drivers:
|
|
|
|
while (--j >= 0)
|
|
|
|
platform_driver_unregister(exynos_drm_non_kms_drivers[j]);
|
|
|
|
|
|
|
|
err_unregister_kms_drivers:
|
|
|
|
while (--i >= 0)
|
|
|
|
platform_driver_unregister(exynos_drm_kms_drivers[i]);
|
|
|
|
|
2014-05-09 12:25:20 +07:00
|
|
|
exynos_drm_remove_vidi();
|
2014-06-17 18:38:07 +07:00
|
|
|
|
|
|
|
err_unregister_pd:
|
|
|
|
platform_device_unregister(exynos_drm_pdev);
|
2014-05-09 12:25:20 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void exynos_drm_exit(void)
|
|
|
|
{
|
drm/exynos: move Exynos platform drivers registration to init
Registering the Exynos DRM subdevices platform drivers in the probe
function is causing an infinite loop. Fix this by moving it to the
exynos_drm_init() function to register the drivers on module init.
Registering drivers in the probe functions causes a deadlock in the parent
device lock. See Grant Likely explanation on the topic:
"I think the problem is that exynos_drm_init() is registering a normal
(non-OF) platform device, so the parent will be /sys/devices/platform.
It immediately gets bound against exynos_drm_platform_driver which
calls the exynos drm_platform_probe() hook. The driver core obtains
device_lock() on the device *and on the device parent*.
Inside the probe hook, additional platform_drivers get registered.
Each time one does, it tries to bind against every platform device in
the system, which includes the ones created by OF. When it attempts to
bind, it obtains device_lock() on the device *and on the device
parent*.
Before the change to move of-generated platform devices into
/sys/devices/platform, the devices had different parents. Now both
devices have /sys/devices/platform as the parent, so yes they are
going to deadlock.
The real problem is registering drivers from within a probe hook. That
is completely wrong for the above deadlock reason. __driver_attach()
will deadlock. Those registrations must be pulled out of .probe().
Registering devices in .probe() is okay because __device_attach()
doesn't try to obtain device_lock() on the parent."
INFO: task swapper/0:1 blocked for more than 120 seconds.
Not tainted 3.18.0-rc3-next-20141105 #794
"echo 0 > /proc/sys/kernel/hung_task_timeout_secs" disables this message.
swapper/0 D c052534c 0 1 0 0x00000000
[<c052534c>] (__schedule) from [<c0525b34>] (schedule_preempt_disabled+0x14/0x20)
[<c0525b34>] (schedule_preempt_disabled) from [<c0526d44>] (mutex_lock_nested+0x1c4/0x464
[<c0526d44>] (mutex_lock_nested) from [<c02be908>] (__driver_attach+0x48/0x98)
[<c02be908>] (__driver_attach) from [<c02bcc00>] (bus_for_each_dev+0x54/0x88)
[<c02bcc00>] (bus_for_each_dev) from [<c02bdce0>] (bus_add_driver+0xe4/0x200)
[<c02bdce0>] (bus_add_driver) from [<c02bef94>] (driver_register+0x78/0xf4)
[<c02bef94>] (driver_register) from [<c029e99c>] (exynos_drm_platform_probe+0x34/0x234)
[<c029e99c>] (exynos_drm_platform_probe) from [<c02bfcf0>] (platform_drv_probe+0x48/0xa4)
[<c02bfcf0>] (platform_drv_probe) from [<c02be680>] (driver_probe_device+0x13c/0x37c)
[<c02be680>] (driver_probe_device) from [<c02be954>] (__driver_attach+0x94/0x98)
[<c02be954>] (__driver_attach) from [<c02bcc00>] (bus_for_each_dev+0x54/0x88)
[<c02bcc00>] (bus_for_each_dev) from [<c02bdce0>] (bus_add_driver+0xe4/0x200)
[<c02bdce0>] (bus_add_driver) from [<c02bef94>] (driver_register+0x78/0xf4)
[<c02bef94>] (driver_register) from [<c029e938>] (exynos_drm_init+0x70/0xa0)
[<c029e938>] (exynos_drm_init) from [<c00089b0>] (do_one_initcall+0xac/0x1f0)
[<c00089b0>] (do_one_initcall) from [<c074bd90>] (kernel_init_freeable+0x10c/0x1d8)
[<c074bd90>] (kernel_init_freeable) from [<c051eabc>] (kernel_init+0x8/0xec)
[<c051eabc>] (kernel_init) from [<c000f268>] (ret_from_fork+0x14/0x2c)
3 locks held by swapper/0/1:
#0: (&dev->mutex){......}, at: [<c02be908>] __driver_attach+0x48/0x98
#1: (&dev->mutex){......}, at: [<c02be918>] __driver_attach+0x58/0x98
#2: (&dev->mutex){......}, at: [<c02be908>] __driver_attach+0x48/0x98
Changelog v2:
- call platform_driver_register after all kms and non kms drivers are
registered
- rebased it to exynos-drm-next
Signed-off-by: Javier Martinez Canillas <javier.martinez@collabora.co.uk>
Signed-off-by: Gustavo Padovan <gustavo.padovan@collabora.co.uk>
Signed-off-by: Inki Dae <inki.dae@samsung.com>
2014-11-24 14:37:26 +07:00
|
|
|
int i;
|
|
|
|
|
|
|
|
#ifdef CONFIG_DRM_EXYNOS_IPP
|
|
|
|
exynos_platform_device_ipp_unregister();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
for (i = ARRAY_SIZE(exynos_drm_non_kms_drivers) - 1; i >= 0; --i)
|
|
|
|
platform_driver_unregister(exynos_drm_non_kms_drivers[i]);
|
|
|
|
|
|
|
|
for (i = ARRAY_SIZE(exynos_drm_kms_drivers) - 1; i >= 0; --i)
|
|
|
|
platform_driver_unregister(exynos_drm_kms_drivers[i]);
|
|
|
|
|
2014-06-17 18:38:07 +07:00
|
|
|
platform_driver_unregister(&exynos_drm_platform_driver);
|
2014-11-13 14:37:57 +07:00
|
|
|
|
2014-05-09 12:25:20 +07:00
|
|
|
exynos_drm_remove_vidi();
|
2014-11-13 14:37:57 +07:00
|
|
|
|
2014-05-09 12:25:20 +07:00
|
|
|
platform_device_unregister(exynos_drm_pdev);
|
2011-10-04 17:19:01 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(exynos_drm_init);
|
|
|
|
module_exit(exynos_drm_exit);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>");
|
|
|
|
MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
|
|
|
|
MODULE_AUTHOR("Seung-Woo Kim <sw0312.kim@samsung.com>");
|
|
|
|
MODULE_DESCRIPTION("Samsung SoC DRM Driver");
|
|
|
|
MODULE_LICENSE("GPL");
|