2011-10-04 04:19:01 -06: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-17 10: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 04:19:01 -06:00
|
|
|
*/
|
|
|
|
|
2014-01-30 14:19:27 -07:00
|
|
|
#include <linux/pm_runtime.h>
|
2012-10-02 11:01:07 -06:00
|
|
|
#include <drm/drmP.h>
|
|
|
|
#include <drm/drm_crtc_helper.h>
|
2011-10-04 04:19:01 -06:00
|
|
|
|
2014-05-08 23:25:20 -06:00
|
|
|
#include <linux/component.h>
|
2013-12-20 03:16:24 -07:00
|
|
|
|
2011-10-04 04:19:01 -06:00
|
|
|
#include <drm/exynos_drm.h>
|
|
|
|
|
|
|
|
#include "exynos_drm_drv.h"
|
|
|
|
#include "exynos_drm_crtc.h"
|
|
|
|
#include "exynos_drm_fbdev.h"
|
|
|
|
#include "exynos_drm_fb.h"
|
|
|
|
#include "exynos_drm_gem.h"
|
2011-12-08 01:54:07 -07:00
|
|
|
#include "exynos_drm_plane.h"
|
2012-03-20 19:55:26 -06:00
|
|
|
#include "exynos_drm_vidi.h"
|
2012-05-17 05:06:32 -06: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 02:10:31 -07:00
|
|
|
#include "exynos_drm_ipp.h"
|
2012-10-20 08:53:42 -06:00
|
|
|
#include "exynos_drm_iommu.h"
|
2011-10-04 04:19:01 -06:00
|
|
|
|
2011-12-15 01:31:24 -07:00
|
|
|
#define DRIVER_NAME "exynos"
|
2011-10-04 04:19:01 -06:00
|
|
|
#define DRIVER_DESC "Samsung SoC DRM"
|
|
|
|
#define DRIVER_DATE "20110530"
|
|
|
|
#define DRIVER_MAJOR 1
|
|
|
|
#define DRIVER_MINOR 0
|
|
|
|
|
|
|
|
static int exynos_drm_load(struct drm_device *dev, unsigned long flags)
|
|
|
|
{
|
|
|
|
struct exynos_drm_private *private;
|
2015-08-06 07:31:47 -06:00
|
|
|
struct drm_encoder *encoder;
|
|
|
|
unsigned int clone_mask;
|
|
|
|
int cnt, ret;
|
2011-10-04 04:19:01 -06:00
|
|
|
|
|
|
|
private = kzalloc(sizeof(struct exynos_drm_private), GFP_KERNEL);
|
2013-08-19 04:04:55 -06:00
|
|
|
if (!private)
|
2011-10-04 04:19:01 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2014-01-30 14:19:27 -07:00
|
|
|
dev_set_drvdata(dev->dev, dev);
|
2011-10-04 04:19:01 -06:00
|
|
|
dev->dev_private = (void *)private;
|
|
|
|
|
2012-10-20 08:53:42 -06: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 02:37:02 -07:00
|
|
|
goto err_free_private;
|
2012-10-20 08:53:42 -06:00
|
|
|
}
|
|
|
|
|
2011-10-04 04:19:01 -06:00
|
|
|
drm_mode_config_init(dev);
|
|
|
|
|
|
|
|
exynos_drm_mode_config_init(dev);
|
|
|
|
|
2012-02-14 19:25:19 -07:00
|
|
|
/* setup possible_clones. */
|
2015-08-06 07:31:47 -06:00
|
|
|
cnt = 0;
|
|
|
|
clone_mask = 0;
|
|
|
|
list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
|
|
|
|
clone_mask |= (1 << (cnt++));
|
|
|
|
|
|
|
|
list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
|
|
|
|
encoder->possible_clones = clone_mask;
|
2012-02-14 19:25:19 -07:00
|
|
|
|
2013-12-11 03:34:23 -07:00
|
|
|
platform_set_drvdata(dev->platformdev, dev);
|
|
|
|
|
2014-05-08 23:25:20 -06:00
|
|
|
/* Try to bind all sub drivers. */
|
|
|
|
ret = component_bind_all(dev->dev, dev);
|
|
|
|
if (ret)
|
2014-10-07 07:09:14 -06:00
|
|
|
goto err_mode_config_cleanup;
|
|
|
|
|
|
|
|
ret = drm_vblank_init(dev, dev->mode_config.num_crtc);
|
|
|
|
if (ret)
|
|
|
|
goto err_unbind_all;
|
2014-05-08 23:25:20 -06:00
|
|
|
|
2014-04-13 21:55:55 -06:00
|
|
|
/* Probe non kms sub drivers and virtual display driver. */
|
2014-05-08 23:25:20 -06:00
|
|
|
ret = exynos_drm_device_subdrv_probe(dev);
|
|
|
|
if (ret)
|
2014-10-07 07:09:14 -06:00
|
|
|
goto err_cleanup_vblank;
|
2014-05-08 23:25:20 -06:00
|
|
|
|
2015-06-01 09:04:44 -06:00
|
|
|
drm_mode_config_reset(dev);
|
|
|
|
|
2014-09-18 02:50:35 -06: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 06:31:54 -06: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 04:19:01 -06:00
|
|
|
return 0;
|
|
|
|
|
2014-05-08 23:25:20 -06:00
|
|
|
err_cleanup_vblank:
|
2011-10-04 04:19:01 -06:00
|
|
|
drm_vblank_cleanup(dev);
|
2014-10-07 07:09:14 -06:00
|
|
|
err_unbind_all:
|
|
|
|
component_unbind_all(dev->dev, dev);
|
2014-02-19 05:02:55 -07:00
|
|
|
err_mode_config_cleanup:
|
|
|
|
drm_mode_config_cleanup(dev);
|
2012-10-20 08:53:42 -06:00
|
|
|
drm_release_iommu_mapping(dev);
|
2014-02-28 02:37:02 -07:00
|
|
|
err_free_private:
|
2011-10-04 04:19:01 -06:00
|
|
|
kfree(private);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int exynos_drm_unload(struct drm_device *dev)
|
|
|
|
{
|
2014-05-08 23:25:20 -06:00
|
|
|
exynos_drm_device_subdrv_remove(dev);
|
|
|
|
|
2011-10-04 04:19:01 -06:00
|
|
|
exynos_drm_fbdev_fini(dev);
|
2011-10-18 01:58:05 -06:00
|
|
|
drm_kms_helper_poll_fini(dev);
|
2012-10-20 08:53:42 -06:00
|
|
|
|
2014-09-09 07:16:06 -06:00
|
|
|
drm_vblank_cleanup(dev);
|
2014-10-07 07:09:14 -06:00
|
|
|
component_unbind_all(dev->dev, dev);
|
2014-09-09 07:16:06 -06:00
|
|
|
drm_mode_config_cleanup(dev);
|
2012-10-20 08:53:42 -06:00
|
|
|
drm_release_iommu_mapping(dev);
|
2011-10-04 04:19:01 -06:00
|
|
|
|
2014-09-09 07:16:06 -06:00
|
|
|
kfree(dev->dev_private);
|
2011-10-04 04:19:01 -06:00
|
|
|
dev->dev_private = NULL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-01-30 14: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 06:31:56 -06:00
|
|
|
if (connector->funcs->dpms) {
|
|
|
|
int dpms = connector->dpms;
|
|
|
|
|
|
|
|
connector->dpms = DRM_MODE_DPMS_OFF;
|
|
|
|
connector->funcs->dpms(connector, dpms);
|
|
|
|
}
|
2014-01-30 14:19:27 -07:00
|
|
|
}
|
2014-05-09 00:14:15 -06:00
|
|
|
drm_modeset_unlock_all(dev);
|
2014-01-30 14:19:27 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-03-16 03:47:09 -06:00
|
|
|
static int exynos_drm_open(struct drm_device *dev, struct drm_file *file)
|
|
|
|
{
|
2012-05-17 05:06:32 -06:00
|
|
|
struct drm_exynos_file_private *file_priv;
|
2013-07-01 02:00:47 -06:00
|
|
|
int ret;
|
2012-05-17 05:06:32 -06:00
|
|
|
|
|
|
|
file_priv = kzalloc(sizeof(*file_priv), GFP_KERNEL);
|
|
|
|
if (!file_priv)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
file->driver_priv = file_priv;
|
2012-04-23 06:01:28 -06:00
|
|
|
|
2013-07-01 02:00:47 -06:00
|
|
|
ret = exynos_drm_subdrv_open(dev, file);
|
2014-01-15 23:01:26 -07:00
|
|
|
if (ret)
|
2014-03-16 21:28:06 -06:00
|
|
|
goto err_file_priv_free;
|
2013-07-01 02:00:47 -06:00
|
|
|
|
2014-01-15 23:01:26 -07:00
|
|
|
return ret;
|
2014-03-16 21:28:06 -06:00
|
|
|
|
|
|
|
err_file_priv_free:
|
2014-01-15 23:01:26 -07:00
|
|
|
kfree(file_priv);
|
|
|
|
file->driver_priv = NULL;
|
2013-07-01 02:00:47 -06:00
|
|
|
return ret;
|
2012-03-16 03:47:09 -06:00
|
|
|
}
|
|
|
|
|
2011-10-13 22:29:51 -06:00
|
|
|
static void exynos_drm_preclose(struct drm_device *dev,
|
2012-02-14 19:25:18 -07:00
|
|
|
struct drm_file *file)
|
2013-09-30 23:51:37 -06:00
|
|
|
{
|
|
|
|
exynos_drm_subdrv_close(dev, file);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void exynos_drm_postclose(struct drm_device *dev, struct drm_file *file)
|
2011-10-13 22:29:51 -06:00
|
|
|
{
|
2013-09-30 23:51:37 -06:00
|
|
|
struct drm_pending_event *e, *et;
|
2012-03-16 03:47:07 -06:00
|
|
|
unsigned long flags;
|
|
|
|
|
2013-09-30 23:51:37 -06:00
|
|
|
if (!file->driver_priv)
|
|
|
|
return;
|
|
|
|
|
2012-03-16 03:47:07 -06:00
|
|
|
spin_lock_irqsave(&dev->event_lock, flags);
|
2013-09-30 23:51:37 -06: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-13 22:29:51 -06:00
|
|
|
|
2012-02-14 19:25:22 -07:00
|
|
|
kfree(file->driver_priv);
|
|
|
|
file->driver_priv = NULL;
|
|
|
|
}
|
|
|
|
|
2011-10-04 04:19:01 -06:00
|
|
|
static void exynos_drm_lastclose(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
exynos_drm_fbdev_restore_mode(dev);
|
|
|
|
}
|
|
|
|
|
2012-05-17 05:27:22 -06:00
|
|
|
static const struct vm_operations_struct exynos_drm_gem_vm_ops = {
|
2011-10-04 04:19:01 -06:00
|
|
|
.fault = exynos_drm_gem_fault,
|
|
|
|
.open = drm_gem_vm_open,
|
|
|
|
.close = drm_gem_vm_close,
|
|
|
|
};
|
|
|
|
|
2013-08-02 11:27:49 -06:00
|
|
|
static const struct drm_ioctl_desc exynos_ioctls[] = {
|
2011-10-04 04:19:01 -06:00
|
|
|
DRM_IOCTL_DEF_DRV(EXYNOS_GEM_CREATE, exynos_drm_gem_create_ioctl,
|
|
|
|
DRM_UNLOCKED | DRM_AUTH),
|
2012-05-04 00:51:17 -06:00
|
|
|
DRM_IOCTL_DEF_DRV(EXYNOS_GEM_GET,
|
|
|
|
exynos_drm_gem_get_ioctl, DRM_UNLOCKED),
|
2012-03-20 19:55:26 -06:00
|
|
|
DRM_IOCTL_DEF_DRV(EXYNOS_VIDI_CONNECTION,
|
|
|
|
vidi_connection_ioctl, DRM_UNLOCKED | DRM_AUTH),
|
2012-05-17 05:06:32 -06: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 02: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 04:19:01 -06:00
|
|
|
};
|
|
|
|
|
2011-12-07 23: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-09 16:40:07 -06:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
.compat_ioctl = drm_compat_ioctl,
|
|
|
|
#endif
|
2011-12-07 23:00:20 -07:00
|
|
|
.release = drm_release,
|
|
|
|
};
|
|
|
|
|
2011-10-04 04:19:01 -06:00
|
|
|
static struct drm_driver exynos_drm_driver = {
|
2014-04-11 18:39:52 -06:00
|
|
|
.driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME,
|
2011-10-04 04:19:01 -06:00
|
|
|
.load = exynos_drm_load,
|
|
|
|
.unload = exynos_drm_unload,
|
2014-01-30 14:19:27 -07:00
|
|
|
.suspend = exynos_drm_suspend,
|
|
|
|
.resume = exynos_drm_resume,
|
2012-03-16 03:47:09 -06:00
|
|
|
.open = exynos_drm_open,
|
2011-10-13 22:29:51 -06:00
|
|
|
.preclose = exynos_drm_preclose,
|
2011-10-04 04:19:01 -06:00
|
|
|
.lastclose = exynos_drm_lastclose,
|
2012-02-14 19:25:22 -07:00
|
|
|
.postclose = exynos_drm_postclose,
|
2014-08-29 04:12:43 -06:00
|
|
|
.set_busid = drm_platform_set_busid,
|
2011-10-04 04:19:01 -06: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 01:12:04 -06:00
|
|
|
.dumb_destroy = drm_gem_dumb_destroy,
|
2012-04-23 06:01:28 -06:00
|
|
|
.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
|
|
|
|
.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
|
2015-08-15 23:33:08 -06:00
|
|
|
.gem_prime_export = drm_gem_prime_export,
|
|
|
|
.gem_prime_import = drm_gem_prime_import,
|
|
|
|
.gem_prime_get_sg_table = exynos_drm_gem_prime_get_sg_table,
|
|
|
|
.gem_prime_import_sg_table = exynos_drm_gem_prime_import_sg_table,
|
|
|
|
.gem_prime_vmap = exynos_drm_gem_prime_vmap,
|
|
|
|
.gem_prime_vunmap = exynos_drm_gem_prime_vunmap,
|
2011-10-04 04:19:01 -06:00
|
|
|
.ioctls = exynos_ioctls,
|
2013-08-02 11:27:49 -06:00
|
|
|
.num_ioctls = ARRAY_SIZE(exynos_ioctls),
|
2011-12-07 23:00:20 -07:00
|
|
|
.fops = &exynos_drm_driver_fops,
|
2011-10-04 04:19:01 -06:00
|
|
|
.name = DRIVER_NAME,
|
|
|
|
.desc = DRIVER_DESC,
|
|
|
|
.date = DRIVER_DATE,
|
|
|
|
.major = DRIVER_MAJOR,
|
|
|
|
.minor = DRIVER_MINOR,
|
|
|
|
};
|
|
|
|
|
2014-01-30 14: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 07:25:44 -06:00
|
|
|
if (pm_runtime_suspended(dev) || !drm_dev)
|
2014-01-30 14: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 07:25:44 -06:00
|
|
|
if (pm_runtime_suspended(dev) || !drm_dev)
|
2014-01-30 14: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)
|
|
|
|
};
|
|
|
|
|
2015-06-11 08:23:37 -06:00
|
|
|
/* forward declaration */
|
|
|
|
static struct platform_driver exynos_drm_platform_driver;
|
2014-05-08 23:25:20 -06:00
|
|
|
|
2015-06-11 08:23:37 -06:00
|
|
|
/*
|
|
|
|
* Connector drivers should not be placed before associated crtc drivers,
|
|
|
|
* because connector requires pipe number of its crtc during initialization.
|
|
|
|
*/
|
|
|
|
static struct platform_driver *const exynos_drm_kms_drivers[] = {
|
|
|
|
#ifdef CONFIG_DRM_EXYNOS_FIMD
|
|
|
|
&fimd_driver,
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_DRM_EXYNOS5433_DECON
|
|
|
|
&exynos5433_decon_driver,
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_DRM_EXYNOS7_DECON
|
|
|
|
&decon_driver,
|
|
|
|
#endif
|
2015-06-12 06:59:02 -06:00
|
|
|
#ifdef CONFIG_DRM_EXYNOS_MIC
|
|
|
|
&mic_driver,
|
|
|
|
#endif
|
2015-06-11 08:23:37 -06:00
|
|
|
#ifdef CONFIG_DRM_EXYNOS_DP
|
|
|
|
&dp_driver,
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_DRM_EXYNOS_DSI
|
|
|
|
&dsi_driver,
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_DRM_EXYNOS_HDMI
|
|
|
|
&mixer_driver,
|
|
|
|
&hdmi_driver,
|
|
|
|
#endif
|
2015-07-14 21:04:39 -06:00
|
|
|
#ifdef CONFIG_DRM_EXYNOS_VIDI
|
|
|
|
&vidi_driver,
|
|
|
|
#endif
|
2015-06-11 08:23:37 -06:00
|
|
|
};
|
2014-05-29 03:28:02 -06:00
|
|
|
|
2015-06-11 08:23:37 -06:00
|
|
|
static struct platform_driver *const exynos_drm_non_kms_drivers[] = {
|
|
|
|
#ifdef CONFIG_DRM_EXYNOS_G2D
|
|
|
|
&g2d_driver,
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_DRM_EXYNOS_FIMC
|
|
|
|
&fimc_driver,
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_DRM_EXYNOS_ROTATOR
|
|
|
|
&rotator_driver,
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_DRM_EXYNOS_GSC
|
|
|
|
&gsc_driver,
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_DRM_EXYNOS_IPP
|
|
|
|
&ipp_driver,
|
|
|
|
#endif
|
|
|
|
&exynos_drm_platform_driver,
|
|
|
|
};
|
2014-05-08 23:25:20 -06:00
|
|
|
|
2015-06-11 08:23:37 -06:00
|
|
|
static struct platform_driver *const exynos_drm_drv_with_simple_dev[] = {
|
|
|
|
#ifdef CONFIG_DRM_EXYNOS_VIDI
|
|
|
|
&vidi_driver,
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_DRM_EXYNOS_IPP
|
|
|
|
&ipp_driver,
|
|
|
|
#endif
|
|
|
|
&exynos_drm_platform_driver,
|
|
|
|
};
|
|
|
|
#define PDEV_COUNT ARRAY_SIZE(exynos_drm_drv_with_simple_dev)
|
2014-05-08 23:25:20 -06:00
|
|
|
|
2014-09-11 02:04:03 -06:00
|
|
|
static int compare_dev(struct device *dev, void *data)
|
2014-05-08 23:25:20 -06:00
|
|
|
{
|
|
|
|
return dev == (struct device *)data;
|
|
|
|
}
|
|
|
|
|
2014-09-11 02:04:03 -06:00
|
|
|
static struct component_match *exynos_drm_match_add(struct device *dev)
|
2014-05-08 23:25:20 -06:00
|
|
|
{
|
2014-09-11 02:04:03 -06:00
|
|
|
struct component_match *match = NULL;
|
2015-06-11 08:23:37 -06:00
|
|
|
int i;
|
2014-05-08 23:25:20 -06:00
|
|
|
|
2015-06-11 08:23:37 -06:00
|
|
|
for (i = 0; i < ARRAY_SIZE(exynos_drm_kms_drivers); ++i) {
|
|
|
|
struct device_driver *drv = &exynos_drm_kms_drivers[i]->driver;
|
|
|
|
struct device *p = NULL, *d;
|
2014-11-06 07:00:37 -07:00
|
|
|
|
2015-06-11 08:23:37 -06:00
|
|
|
while ((d = bus_find_device(&platform_bus_type, p, drv,
|
|
|
|
(void *)platform_bus_type.match))) {
|
|
|
|
put_device(p);
|
|
|
|
component_match_add(dev, &match, compare_dev, d);
|
|
|
|
p = d;
|
2014-05-29 03:28:02 -06:00
|
|
|
}
|
2015-06-11 08:23:37 -06:00
|
|
|
put_device(p);
|
2014-05-08 23:25:20 -06:00
|
|
|
}
|
|
|
|
|
2015-06-11 08:23:37 -06:00
|
|
|
return match ?: ERR_PTR(-ENODEV);
|
2014-05-08 23:25:20 -06: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 04:19:01 -06:00
|
|
|
};
|
|
|
|
|
2015-06-11 08:20:52 -06:00
|
|
|
static int exynos_drm_platform_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct component_match *match;
|
|
|
|
|
|
|
|
pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
|
|
|
|
exynos_drm_driver.num_ioctls = ARRAY_SIZE(exynos_ioctls);
|
|
|
|
|
|
|
|
match = exynos_drm_match_add(&pdev->dev);
|
|
|
|
if (IS_ERR(match))
|
|
|
|
return PTR_ERR(match);
|
|
|
|
|
|
|
|
return component_master_add_with_match(&pdev->dev, &exynos_drm_ops,
|
|
|
|
match);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int exynos_drm_platform_remove(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
component_master_del(&pdev->dev, &exynos_drm_ops);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
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 struct platform_device *exynos_drm_pdevs[PDEV_COUNT];
|
|
|
|
|
|
|
|
static void exynos_drm_unregister_devices(void)
|
2014-11-13 00:37:57 -07:00
|
|
|
{
|
2015-06-11 08:20:52 -06:00
|
|
|
int i = PDEV_COUNT;
|
2014-03-17 04:27:17 -06:00
|
|
|
|
2015-06-11 08:20:52 -06:00
|
|
|
while (--i >= 0) {
|
|
|
|
platform_device_unregister(exynos_drm_pdevs[i]);
|
|
|
|
exynos_drm_pdevs[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
2014-04-03 10:19:56 -06:00
|
|
|
|
2015-06-11 08:20:52 -06:00
|
|
|
static int exynos_drm_register_devices(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < PDEV_COUNT; ++i) {
|
|
|
|
struct platform_driver *d = exynos_drm_drv_with_simple_dev[i];
|
|
|
|
struct platform_device *pdev =
|
|
|
|
platform_device_register_simple(d->driver.name, -1,
|
|
|
|
NULL, 0);
|
|
|
|
|
|
|
|
if (!IS_ERR(pdev)) {
|
|
|
|
exynos_drm_pdevs[i] = pdev;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
while (--i >= 0) {
|
|
|
|
platform_device_unregister(exynos_drm_pdevs[i]);
|
|
|
|
exynos_drm_pdevs[i] = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return PTR_ERR(pdev);
|
2014-11-13 00:37:57 -07:00
|
|
|
}
|
2014-05-08 23:25:20 -06:00
|
|
|
|
2015-06-11 08:20:52 -06:00
|
|
|
return 0;
|
2011-10-04 04:19:01 -06:00
|
|
|
}
|
|
|
|
|
2015-06-11 08:20:52 -06:00
|
|
|
static void exynos_drm_unregister_drivers(struct platform_driver * const *drv,
|
|
|
|
int count)
|
2011-10-04 04:19:01 -06:00
|
|
|
{
|
2015-06-11 08:20:52 -06:00
|
|
|
while (--count >= 0)
|
|
|
|
platform_driver_unregister(drv[count]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int exynos_drm_register_drivers(struct platform_driver * const *drv,
|
|
|
|
int count)
|
|
|
|
{
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
for (i = 0; i < count; ++i) {
|
|
|
|
ret = platform_driver_register(drv[i]);
|
|
|
|
if (!ret)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
while (--i >= 0)
|
|
|
|
platform_driver_unregister(drv[i]);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-05-08 23:25:20 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-06-11 08:20:52 -06:00
|
|
|
static inline int exynos_drm_register_kms_drivers(void)
|
|
|
|
{
|
|
|
|
return exynos_drm_register_drivers(exynos_drm_kms_drivers,
|
|
|
|
ARRAY_SIZE(exynos_drm_kms_drivers));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int exynos_drm_register_non_kms_drivers(void)
|
|
|
|
{
|
|
|
|
return exynos_drm_register_drivers(exynos_drm_non_kms_drivers,
|
|
|
|
ARRAY_SIZE(exynos_drm_non_kms_drivers));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void exynos_drm_unregister_kms_drivers(void)
|
|
|
|
{
|
|
|
|
exynos_drm_unregister_drivers(exynos_drm_kms_drivers,
|
|
|
|
ARRAY_SIZE(exynos_drm_kms_drivers));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void exynos_drm_unregister_non_kms_drivers(void)
|
|
|
|
{
|
|
|
|
exynos_drm_unregister_drivers(exynos_drm_non_kms_drivers,
|
|
|
|
ARRAY_SIZE(exynos_drm_non_kms_drivers));
|
|
|
|
}
|
|
|
|
|
2014-05-08 23:25:20 -06:00
|
|
|
static int exynos_drm_init(void)
|
|
|
|
{
|
2015-06-08 04:15:42 -06:00
|
|
|
int ret;
|
2014-05-08 23:25:20 -06:00
|
|
|
|
2015-06-11 08:20:52 -06:00
|
|
|
ret = exynos_drm_register_devices();
|
|
|
|
if (ret)
|
|
|
|
return 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 00:37:26 -07:00
|
|
|
|
2015-06-11 08:20:52 -06:00
|
|
|
ret = exynos_drm_register_kms_drivers();
|
|
|
|
if (ret)
|
|
|
|
goto err_unregister_pdevs;
|
2014-05-08 23:25:20 -06:00
|
|
|
|
2015-06-11 08:20:52 -06:00
|
|
|
ret = exynos_drm_register_non_kms_drivers();
|
2014-05-08 23:25:20 -06:00
|
|
|
if (ret)
|
2015-06-11 08:20:52 -06:00
|
|
|
goto err_unregister_kms_drivers;
|
2014-05-08 23:25:20 -06: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 00:37:26 -07:00
|
|
|
err_unregister_kms_drivers:
|
2015-06-11 08:20:52 -06:00
|
|
|
exynos_drm_unregister_kms_drivers();
|
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 00:37:26 -07:00
|
|
|
|
2015-06-11 08:20:52 -06:00
|
|
|
err_unregister_pdevs:
|
|
|
|
exynos_drm_unregister_devices();
|
2014-05-08 23:25:20 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void exynos_drm_exit(void)
|
|
|
|
{
|
2015-06-11 08:20:52 -06:00
|
|
|
exynos_drm_unregister_non_kms_drivers();
|
|
|
|
exynos_drm_unregister_kms_drivers();
|
|
|
|
exynos_drm_unregister_devices();
|
2011-10-04 04:19:01 -06: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");
|