drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2013 Red Hat
|
|
|
|
* Author: Rob Clark <robdclark@gmail.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms of the GNU General Public License version 2 as published by
|
|
|
|
* the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
|
* more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along with
|
|
|
|
* this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2016-10-19 10:28:27 +00:00
|
|
|
#include <drm/drm_of.h>
|
|
|
|
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
#include "msm_drv.h"
|
2016-03-16 16:56:12 +00:00
|
|
|
#include "msm_debugfs.h"
|
2016-03-15 19:35:08 +00:00
|
|
|
#include "msm_fence.h"
|
2013-07-19 16:59:32 +00:00
|
|
|
#include "msm_gpu.h"
|
2013-11-30 21:12:10 +00:00
|
|
|
#include "msm_kms.h"
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
|
2016-06-01 18:02:02 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* MSM driver version:
|
|
|
|
* - 1.0.0 - initial interface
|
|
|
|
* - 1.1.0 - adds madvise, and support for submits with > 4 cmd buffers
|
2016-09-16 22:37:44 +00:00
|
|
|
* - 1.2.0 - adds explicit fence support for submit ioctl
|
2017-10-20 17:06:55 +00:00
|
|
|
* - 1.3.0 - adds GMEM_BASE + NR_RINGS params, SUBMITQUEUE_NEW +
|
|
|
|
* SUBMITQUEUE_CLOSE ioctls, and MSM_INFO_IOVA flag for
|
|
|
|
* MSM_GEM_INFO ioctl.
|
2016-06-01 18:02:02 +00:00
|
|
|
*/
|
|
|
|
#define MSM_VERSION_MAJOR 1
|
2017-10-20 17:06:55 +00:00
|
|
|
#define MSM_VERSION_MINOR 3
|
2016-06-01 18:02:02 +00:00
|
|
|
#define MSM_VERSION_PATCHLEVEL 0
|
|
|
|
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
static void msm_fb_output_poll_changed(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct msm_drm_private *priv = dev->dev_private;
|
|
|
|
if (priv->fbdev)
|
|
|
|
drm_fb_helper_hotplug_event(priv->fbdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct drm_mode_config_funcs mode_config_funcs = {
|
|
|
|
.fb_create = msm_framebuffer_create,
|
|
|
|
.output_poll_changed = msm_fb_output_poll_changed,
|
2014-11-26 16:02:18 +00:00
|
|
|
.atomic_check = msm_atomic_check,
|
2014-11-08 18:21:06 +00:00
|
|
|
.atomic_commit = msm_atomic_commit,
|
2016-11-04 17:51:42 +00:00
|
|
|
.atomic_state_alloc = msm_atomic_state_alloc,
|
|
|
|
.atomic_state_clear = msm_atomic_state_clear,
|
|
|
|
.atomic_state_free = msm_atomic_state_free,
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef CONFIG_DRM_MSM_REGISTER_LOGGING
|
|
|
|
static bool reglog = false;
|
|
|
|
MODULE_PARM_DESC(reglog, "Enable register read/write logging");
|
|
|
|
module_param(reglog, bool, 0600);
|
|
|
|
#else
|
|
|
|
#define reglog 0
|
|
|
|
#endif
|
|
|
|
|
2015-07-13 06:42:07 +00:00
|
|
|
#ifdef CONFIG_DRM_FBDEV_EMULATION
|
2015-01-30 22:05:41 +00:00
|
|
|
static bool fbdev = true;
|
|
|
|
MODULE_PARM_DESC(fbdev, "Enable fbdev compat layer");
|
|
|
|
module_param(fbdev, bool, 0600);
|
|
|
|
#endif
|
|
|
|
|
2014-09-08 18:24:57 +00:00
|
|
|
static char *vram = "16m";
|
2016-02-03 19:02:04 +00:00
|
|
|
MODULE_PARM_DESC(vram, "Configure VRAM size (for devices without IOMMU/GPUMMU)");
|
2013-11-16 17:56:06 +00:00
|
|
|
module_param(vram, charp, 0);
|
|
|
|
|
2016-11-05 15:08:12 +00:00
|
|
|
bool dumpstate = false;
|
|
|
|
MODULE_PARM_DESC(dumpstate, "Dump KMS state on errors");
|
|
|
|
module_param(dumpstate, bool, 0600);
|
|
|
|
|
2017-07-06 20:33:44 +00:00
|
|
|
static bool modeset = true;
|
|
|
|
MODULE_PARM_DESC(modeset, "Use kernel modesetting [KMS] (1=on (default), 0=disable)");
|
|
|
|
module_param(modeset, bool, 0600);
|
|
|
|
|
2014-03-03 19:19:12 +00:00
|
|
|
/*
|
|
|
|
* Util/helpers:
|
|
|
|
*/
|
|
|
|
|
2017-01-30 16:30:58 +00:00
|
|
|
struct clk *msm_clk_get(struct platform_device *pdev, const char *name)
|
|
|
|
{
|
|
|
|
struct clk *clk;
|
|
|
|
char name2[32];
|
|
|
|
|
|
|
|
clk = devm_clk_get(&pdev->dev, name);
|
|
|
|
if (!IS_ERR(clk) || PTR_ERR(clk) == -EPROBE_DEFER)
|
|
|
|
return clk;
|
|
|
|
|
|
|
|
snprintf(name2, sizeof(name2), "%s_clk", name);
|
|
|
|
|
|
|
|
clk = devm_clk_get(&pdev->dev, name2);
|
|
|
|
if (!IS_ERR(clk))
|
|
|
|
dev_warn(&pdev->dev, "Using legacy clk name binding. Use "
|
|
|
|
"\"%s\" instead of \"%s\"\n", name, name2);
|
|
|
|
|
|
|
|
return clk;
|
|
|
|
}
|
|
|
|
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
void __iomem *msm_ioremap(struct platform_device *pdev, const char *name,
|
|
|
|
const char *dbgname)
|
|
|
|
{
|
|
|
|
struct resource *res;
|
|
|
|
unsigned long size;
|
|
|
|
void __iomem *ptr;
|
|
|
|
|
|
|
|
if (name)
|
|
|
|
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
|
|
|
|
else
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
|
|
|
|
if (!res) {
|
|
|
|
dev_err(&pdev->dev, "failed to get memory resource: %s\n", name);
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
size = resource_size(res);
|
|
|
|
|
|
|
|
ptr = devm_ioremap_nocache(&pdev->dev, res->start, size);
|
|
|
|
if (!ptr) {
|
|
|
|
dev_err(&pdev->dev, "failed to ioremap: %s\n", name);
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (reglog)
|
2015-04-09 14:39:51 +00:00
|
|
|
printk(KERN_DEBUG "IO:region %s %p %08lx\n", dbgname, ptr, size);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void msm_writel(u32 data, void __iomem *addr)
|
|
|
|
{
|
|
|
|
if (reglog)
|
2015-04-09 14:39:51 +00:00
|
|
|
printk(KERN_DEBUG "IO:W %p %08x\n", addr, data);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
writel(data, addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
u32 msm_readl(const void __iomem *addr)
|
|
|
|
{
|
|
|
|
u32 val = readl(addr);
|
|
|
|
if (reglog)
|
2017-02-28 12:55:54 +00:00
|
|
|
pr_err("IO:R %p %08x\n", addr, val);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2015-07-27 17:49:45 +00:00
|
|
|
struct vblank_event {
|
|
|
|
struct list_head node;
|
|
|
|
int crtc_id;
|
|
|
|
bool enable;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void vblank_ctrl_worker(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct msm_vblank_ctrl *vbl_ctrl = container_of(work,
|
|
|
|
struct msm_vblank_ctrl, work);
|
|
|
|
struct msm_drm_private *priv = container_of(vbl_ctrl,
|
|
|
|
struct msm_drm_private, vblank_ctrl);
|
|
|
|
struct msm_kms *kms = priv->kms;
|
|
|
|
struct vblank_event *vbl_ev, *tmp;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&vbl_ctrl->lock, flags);
|
|
|
|
list_for_each_entry_safe(vbl_ev, tmp, &vbl_ctrl->event_list, node) {
|
|
|
|
list_del(&vbl_ev->node);
|
|
|
|
spin_unlock_irqrestore(&vbl_ctrl->lock, flags);
|
|
|
|
|
|
|
|
if (vbl_ev->enable)
|
|
|
|
kms->funcs->enable_vblank(kms,
|
|
|
|
priv->crtcs[vbl_ev->crtc_id]);
|
|
|
|
else
|
|
|
|
kms->funcs->disable_vblank(kms,
|
|
|
|
priv->crtcs[vbl_ev->crtc_id]);
|
|
|
|
|
|
|
|
kfree(vbl_ev);
|
|
|
|
|
|
|
|
spin_lock_irqsave(&vbl_ctrl->lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&vbl_ctrl->lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vblank_ctrl_queue_work(struct msm_drm_private *priv,
|
|
|
|
int crtc_id, bool enable)
|
|
|
|
{
|
|
|
|
struct msm_vblank_ctrl *vbl_ctrl = &priv->vblank_ctrl;
|
|
|
|
struct vblank_event *vbl_ev;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
vbl_ev = kzalloc(sizeof(*vbl_ev), GFP_ATOMIC);
|
|
|
|
if (!vbl_ev)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
vbl_ev->crtc_id = crtc_id;
|
|
|
|
vbl_ev->enable = enable;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&vbl_ctrl->lock, flags);
|
|
|
|
list_add_tail(&vbl_ev->node, &vbl_ctrl->event_list);
|
|
|
|
spin_unlock_irqrestore(&vbl_ctrl->lock, flags);
|
|
|
|
|
|
|
|
queue_work(priv->wq, &vbl_ctrl->work);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-05-02 05:35:54 +00:00
|
|
|
static int msm_drm_uninit(struct device *dev)
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
{
|
2016-05-02 05:35:54 +00:00
|
|
|
struct platform_device *pdev = to_platform_device(dev);
|
|
|
|
struct drm_device *ddev = platform_get_drvdata(pdev);
|
|
|
|
struct msm_drm_private *priv = ddev->dev_private;
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
struct msm_kms *kms = priv->kms;
|
2015-07-27 17:49:45 +00:00
|
|
|
struct msm_vblank_ctrl *vbl_ctrl = &priv->vblank_ctrl;
|
|
|
|
struct vblank_event *vbl_ev, *tmp;
|
|
|
|
|
|
|
|
/* We must cancel and cleanup any pending vblank enable/disable
|
|
|
|
* work before drm_irq_uninstall() to avoid work re-enabling an
|
|
|
|
* irq after uninstall has disabled it.
|
|
|
|
*/
|
|
|
|
cancel_work_sync(&vbl_ctrl->work);
|
|
|
|
list_for_each_entry_safe(vbl_ev, tmp, &vbl_ctrl->event_list, node) {
|
|
|
|
list_del(&vbl_ev->node);
|
|
|
|
kfree(vbl_ev);
|
|
|
|
}
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
|
2016-05-17 20:19:32 +00:00
|
|
|
msm_gem_shrinker_cleanup(ddev);
|
|
|
|
|
2016-05-02 05:35:54 +00:00
|
|
|
drm_kms_helper_poll_fini(ddev);
|
|
|
|
|
|
|
|
drm_dev_unregister(ddev);
|
2016-05-02 05:35:53 +00:00
|
|
|
|
2017-03-07 20:49:22 +00:00
|
|
|
msm_perf_debugfs_cleanup(priv);
|
|
|
|
msm_rd_debugfs_cleanup(priv);
|
|
|
|
|
2016-02-25 05:49:45 +00:00
|
|
|
#ifdef CONFIG_DRM_FBDEV_EMULATION
|
|
|
|
if (fbdev && priv->fbdev)
|
2016-05-02 05:35:54 +00:00
|
|
|
msm_fbdev_free(ddev);
|
2016-02-25 05:49:45 +00:00
|
|
|
#endif
|
2016-05-02 05:35:54 +00:00
|
|
|
drm_mode_config_cleanup(ddev);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
|
2016-05-02 05:35:54 +00:00
|
|
|
pm_runtime_get_sync(dev);
|
|
|
|
drm_irq_uninstall(ddev);
|
|
|
|
pm_runtime_put_sync(dev);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
|
|
|
|
flush_workqueue(priv->wq);
|
|
|
|
destroy_workqueue(priv->wq);
|
|
|
|
|
2016-03-16 22:18:17 +00:00
|
|
|
flush_workqueue(priv->atomic_wq);
|
|
|
|
destroy_workqueue(priv->atomic_wq);
|
|
|
|
|
2016-11-03 12:06:18 +00:00
|
|
|
if (kms && kms->funcs)
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
kms->funcs->destroy(kms);
|
|
|
|
|
2013-11-16 17:56:06 +00:00
|
|
|
if (priv->vram.paddr) {
|
2016-08-03 20:46:00 +00:00
|
|
|
unsigned long attrs = DMA_ATTR_NO_KERNEL_MAPPING;
|
2013-11-16 17:56:06 +00:00
|
|
|
drm_mm_takedown(&priv->vram.mm);
|
2016-05-02 05:35:54 +00:00
|
|
|
dma_free_attrs(dev, priv->vram.size, NULL,
|
2016-08-03 20:46:00 +00:00
|
|
|
priv->vram.paddr, attrs);
|
2013-11-16 17:56:06 +00:00
|
|
|
}
|
|
|
|
|
2016-05-02 05:35:54 +00:00
|
|
|
component_unbind_all(dev, ddev);
|
2014-03-03 19:19:12 +00:00
|
|
|
|
2016-05-08 16:06:28 +00:00
|
|
|
msm_mdss_destroy(ddev);
|
|
|
|
|
2016-05-02 05:35:54 +00:00
|
|
|
ddev->dev_private = NULL;
|
|
|
|
drm_dev_unref(ddev);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
|
|
|
|
kfree(priv);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
drm/msm: add mdp5/apq8x74
Add support for the new MDP5 display controller block. The mapping
between parts of the display controller and KMS is:
plane -> PIPE{RGBn,VIGn} \
crtc -> LM (layer mixer) |-> MDP "device"
encoder -> INTF /
connector -> HDMI/DSI/eDP/etc --> other device(s)
Unlike MDP4, it appears we can get by with a single encoder, rather
than needing a different implementation for DTV, DSI, etc. (Ie. the
register interface is same, just different bases.)
Also unlike MDP4, all the IRQs for other blocks (HDMI, DSI, etc) are
routed through MDP.
And finally, MDP5 has this "Shared Memory Pool" (called "SMP"), from
which blocks need to be allocated to the active pipes based on fetch
stride.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-11-30 22:51:47 +00:00
|
|
|
static int get_mdp_ver(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct device *dev = &pdev->dev;
|
2015-11-18 06:45:14 +00:00
|
|
|
|
|
|
|
return (int) (unsigned long) of_device_get_match_data(dev);
|
drm/msm: add mdp5/apq8x74
Add support for the new MDP5 display controller block. The mapping
between parts of the display controller and KMS is:
plane -> PIPE{RGBn,VIGn} \
crtc -> LM (layer mixer) |-> MDP "device"
encoder -> INTF /
connector -> HDMI/DSI/eDP/etc --> other device(s)
Unlike MDP4, it appears we can get by with a single encoder, rather
than needing a different implementation for DTV, DSI, etc. (Ie. the
register interface is same, just different bases.)
Also unlike MDP4, all the IRQs for other blocks (HDMI, DSI, etc) are
routed through MDP.
And finally, MDP5 has this "Shared Memory Pool" (called "SMP"), from
which blocks need to be allocated to the active pipes based on fetch
stride.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-11-30 22:51:47 +00:00
|
|
|
}
|
|
|
|
|
2015-03-03 20:04:25 +00:00
|
|
|
#include <linux/of_address.h>
|
|
|
|
|
2015-03-03 20:04:24 +00:00
|
|
|
static int msm_init_vram(struct drm_device *dev)
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
{
|
2015-03-03 20:04:24 +00:00
|
|
|
struct msm_drm_private *priv = dev->dev_private;
|
2015-11-18 06:45:14 +00:00
|
|
|
struct device_node *node;
|
2015-03-03 20:04:25 +00:00
|
|
|
unsigned long size = 0;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* In the device-tree world, we could have a 'memory-region'
|
|
|
|
* phandle, which gives us a link to our "vram". Allocating
|
|
|
|
* is all nicely abstracted behind the dma api, but we need
|
|
|
|
* to know the entire size to allocate it all in one go. There
|
|
|
|
* are two cases:
|
|
|
|
* 1) device with no IOMMU, in which case we need exclusive
|
|
|
|
* access to a VRAM carveout big enough for all gpu
|
|
|
|
* buffers
|
|
|
|
* 2) device with IOMMU, but where the bootloader puts up
|
|
|
|
* a splash screen. In this case, the VRAM carveout
|
|
|
|
* need only be large enough for fbdev fb. But we need
|
|
|
|
* exclusive access to the buffer to avoid the kernel
|
|
|
|
* using those pages for other purposes (which appears
|
|
|
|
* as corruption on screen before we have a chance to
|
|
|
|
* load and do initial modeset)
|
|
|
|
*/
|
|
|
|
|
|
|
|
node = of_parse_phandle(dev->dev->of_node, "memory-region", 0);
|
|
|
|
if (node) {
|
|
|
|
struct resource r;
|
|
|
|
ret = of_address_to_resource(node, 0, &r);
|
2016-07-04 08:49:50 +00:00
|
|
|
of_node_put(node);
|
2015-03-03 20:04:25 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
size = r.end - r.start;
|
2015-04-09 14:39:51 +00:00
|
|
|
DRM_INFO("using VRAM carveout: %lx@%pa\n", size, &r.start);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
|
2015-11-18 06:45:14 +00:00
|
|
|
/* if we have no IOMMU, then we need to use carveout allocator.
|
|
|
|
* Grab the entire CMA chunk carved out in early startup in
|
|
|
|
* mach-msm:
|
|
|
|
*/
|
|
|
|
} else if (!iommu_present(&platform_bus_type)) {
|
2015-03-03 20:04:25 +00:00
|
|
|
DRM_INFO("using %s VRAM carveout\n", vram);
|
|
|
|
size = memparse(vram, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (size) {
|
2016-08-03 20:46:00 +00:00
|
|
|
unsigned long attrs = 0;
|
2013-11-16 17:56:06 +00:00
|
|
|
void *p;
|
|
|
|
|
|
|
|
priv->vram.size = size;
|
|
|
|
|
|
|
|
drm_mm_init(&priv->vram.mm, 0, (size >> PAGE_SHIFT) - 1);
|
2017-06-13 22:52:54 +00:00
|
|
|
spin_lock_init(&priv->vram.lock);
|
2013-11-16 17:56:06 +00:00
|
|
|
|
2016-08-03 20:46:00 +00:00
|
|
|
attrs |= DMA_ATTR_NO_KERNEL_MAPPING;
|
|
|
|
attrs |= DMA_ATTR_WRITE_COMBINE;
|
2013-11-16 17:56:06 +00:00
|
|
|
|
|
|
|
/* note that for no-kernel-mapping, the vaddr returned
|
|
|
|
* is bogus, but non-null if allocation succeeded:
|
|
|
|
*/
|
|
|
|
p = dma_alloc_attrs(dev->dev, size,
|
2016-08-03 20:46:00 +00:00
|
|
|
&priv->vram.paddr, GFP_KERNEL, attrs);
|
2013-11-16 17:56:06 +00:00
|
|
|
if (!p) {
|
|
|
|
dev_err(dev->dev, "failed to allocate VRAM\n");
|
|
|
|
priv->vram.paddr = 0;
|
2015-03-03 20:04:24 +00:00
|
|
|
return -ENOMEM;
|
2013-11-16 17:56:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
dev_info(dev->dev, "VRAM: %08x->%08x\n",
|
|
|
|
(uint32_t)priv->vram.paddr,
|
|
|
|
(uint32_t)(priv->vram.paddr + size));
|
|
|
|
}
|
|
|
|
|
2015-03-03 20:04:25 +00:00
|
|
|
return ret;
|
2015-03-03 20:04:24 +00:00
|
|
|
}
|
|
|
|
|
2016-05-02 05:35:54 +00:00
|
|
|
static int msm_drm_init(struct device *dev, struct drm_driver *drv)
|
2015-03-03 20:04:24 +00:00
|
|
|
{
|
2016-05-02 05:35:54 +00:00
|
|
|
struct platform_device *pdev = to_platform_device(dev);
|
|
|
|
struct drm_device *ddev;
|
2015-03-03 20:04:24 +00:00
|
|
|
struct msm_drm_private *priv;
|
|
|
|
struct msm_kms *kms;
|
|
|
|
int ret;
|
|
|
|
|
2016-05-02 05:35:54 +00:00
|
|
|
ddev = drm_dev_alloc(drv, dev);
|
2016-09-21 14:59:19 +00:00
|
|
|
if (IS_ERR(ddev)) {
|
2016-05-02 05:35:54 +00:00
|
|
|
dev_err(dev, "failed to allocate drm_device\n");
|
2016-09-21 14:59:19 +00:00
|
|
|
return PTR_ERR(ddev);
|
2016-05-02 05:35:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
platform_set_drvdata(pdev, ddev);
|
|
|
|
|
2015-03-03 20:04:24 +00:00
|
|
|
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
|
|
|
|
if (!priv) {
|
2016-05-02 05:35:54 +00:00
|
|
|
drm_dev_unref(ddev);
|
2015-03-03 20:04:24 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2016-05-02 05:35:54 +00:00
|
|
|
ddev->dev_private = priv;
|
2016-05-17 20:19:32 +00:00
|
|
|
priv->dev = ddev;
|
2015-03-03 20:04:24 +00:00
|
|
|
|
2016-05-08 16:06:28 +00:00
|
|
|
ret = msm_mdss_init(ddev);
|
|
|
|
if (ret) {
|
|
|
|
kfree(priv);
|
|
|
|
drm_dev_unref(ddev);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-03-03 20:04:24 +00:00
|
|
|
priv->wq = alloc_ordered_workqueue("msm", 0);
|
2016-03-16 22:18:17 +00:00
|
|
|
priv->atomic_wq = alloc_ordered_workqueue("msm:atomic", 0);
|
2015-03-03 20:04:24 +00:00
|
|
|
init_waitqueue_head(&priv->pending_crtcs_event);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&priv->inactive_list);
|
2015-07-27 17:49:45 +00:00
|
|
|
INIT_LIST_HEAD(&priv->vblank_ctrl.event_list);
|
|
|
|
INIT_WORK(&priv->vblank_ctrl.work, vblank_ctrl_worker);
|
|
|
|
spin_lock_init(&priv->vblank_ctrl.lock);
|
2015-03-03 20:04:24 +00:00
|
|
|
|
2016-05-02 05:35:54 +00:00
|
|
|
drm_mode_config_init(ddev);
|
2014-03-03 19:19:12 +00:00
|
|
|
|
|
|
|
/* Bind all our sub-components: */
|
2016-05-02 05:35:54 +00:00
|
|
|
ret = component_bind_all(dev, ddev);
|
|
|
|
if (ret) {
|
2016-05-08 16:06:28 +00:00
|
|
|
msm_mdss_destroy(ddev);
|
2016-05-02 05:35:54 +00:00
|
|
|
kfree(priv);
|
|
|
|
drm_dev_unref(ddev);
|
2014-03-03 19:19:12 +00:00
|
|
|
return ret;
|
2016-05-02 05:35:54 +00:00
|
|
|
}
|
2014-03-03 19:19:12 +00:00
|
|
|
|
2016-05-02 05:35:54 +00:00
|
|
|
ret = msm_init_vram(ddev);
|
2015-05-07 19:20:13 +00:00
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
|
2016-05-17 20:19:32 +00:00
|
|
|
msm_gem_shrinker_init(ddev);
|
|
|
|
|
drm/msm: add mdp5/apq8x74
Add support for the new MDP5 display controller block. The mapping
between parts of the display controller and KMS is:
plane -> PIPE{RGBn,VIGn} \
crtc -> LM (layer mixer) |-> MDP "device"
encoder -> INTF /
connector -> HDMI/DSI/eDP/etc --> other device(s)
Unlike MDP4, it appears we can get by with a single encoder, rather
than needing a different implementation for DTV, DSI, etc. (Ie. the
register interface is same, just different bases.)
Also unlike MDP4, all the IRQs for other blocks (HDMI, DSI, etc) are
routed through MDP.
And finally, MDP5 has this "Shared Memory Pool" (called "SMP"), from
which blocks need to be allocated to the active pipes based on fetch
stride.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-11-30 22:51:47 +00:00
|
|
|
switch (get_mdp_ver(pdev)) {
|
|
|
|
case 4:
|
2016-05-02 05:35:54 +00:00
|
|
|
kms = mdp4_kms_init(ddev);
|
2016-05-08 16:06:28 +00:00
|
|
|
priv->kms = kms;
|
drm/msm: add mdp5/apq8x74
Add support for the new MDP5 display controller block. The mapping
between parts of the display controller and KMS is:
plane -> PIPE{RGBn,VIGn} \
crtc -> LM (layer mixer) |-> MDP "device"
encoder -> INTF /
connector -> HDMI/DSI/eDP/etc --> other device(s)
Unlike MDP4, it appears we can get by with a single encoder, rather
than needing a different implementation for DTV, DSI, etc. (Ie. the
register interface is same, just different bases.)
Also unlike MDP4, all the IRQs for other blocks (HDMI, DSI, etc) are
routed through MDP.
And finally, MDP5 has this "Shared Memory Pool" (called "SMP"), from
which blocks need to be allocated to the active pipes based on fetch
stride.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-11-30 22:51:47 +00:00
|
|
|
break;
|
|
|
|
case 5:
|
2016-06-14 12:54:54 +00:00
|
|
|
kms = mdp5_kms_init(ddev);
|
drm/msm: add mdp5/apq8x74
Add support for the new MDP5 display controller block. The mapping
between parts of the display controller and KMS is:
plane -> PIPE{RGBn,VIGn} \
crtc -> LM (layer mixer) |-> MDP "device"
encoder -> INTF /
connector -> HDMI/DSI/eDP/etc --> other device(s)
Unlike MDP4, it appears we can get by with a single encoder, rather
than needing a different implementation for DTV, DSI, etc. (Ie. the
register interface is same, just different bases.)
Also unlike MDP4, all the IRQs for other blocks (HDMI, DSI, etc) are
routed through MDP.
And finally, MDP5 has this "Shared Memory Pool" (called "SMP"), from
which blocks need to be allocated to the active pipes based on fetch
stride.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-11-30 22:51:47 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
kms = ERR_PTR(-ENODEV);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
if (IS_ERR(kms)) {
|
|
|
|
/*
|
|
|
|
* NOTE: once we have GPU support, having no kms should not
|
|
|
|
* be considered fatal.. ideally we would still support gpu
|
|
|
|
* and (for example) use dmabuf/prime to share buffers with
|
|
|
|
* imx drm driver on iMX5
|
|
|
|
*/
|
2016-05-02 05:35:54 +00:00
|
|
|
dev_err(dev, "failed to load kms\n");
|
2013-09-16 21:19:54 +00:00
|
|
|
ret = PTR_ERR(kms);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (kms) {
|
|
|
|
ret = kms->funcs->hw_init(kms);
|
|
|
|
if (ret) {
|
2016-05-02 05:35:54 +00:00
|
|
|
dev_err(dev, "kms hw init failed: %d\n", ret);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-02 05:35:54 +00:00
|
|
|
ddev->mode_config.funcs = &mode_config_funcs;
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
|
2016-05-02 05:35:54 +00:00
|
|
|
ret = drm_vblank_init(ddev, priv->num_crtcs);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
if (ret < 0) {
|
2016-05-02 05:35:54 +00:00
|
|
|
dev_err(dev, "failed to initialize vblank\n");
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2016-05-18 09:36:03 +00:00
|
|
|
if (kms) {
|
|
|
|
pm_runtime_get_sync(dev);
|
|
|
|
ret = drm_irq_install(ddev, kms->irq);
|
|
|
|
pm_runtime_put_sync(dev);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(dev, "failed to install IRQ handler\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
}
|
|
|
|
|
2016-05-02 05:35:54 +00:00
|
|
|
ret = drm_dev_register(ddev, 0);
|
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
drm_mode_config_reset(ddev);
|
2014-11-08 18:21:06 +00:00
|
|
|
|
2015-07-13 06:42:07 +00:00
|
|
|
#ifdef CONFIG_DRM_FBDEV_EMULATION
|
2015-01-30 22:05:41 +00:00
|
|
|
if (fbdev)
|
2016-05-02 05:35:54 +00:00
|
|
|
priv->fbdev = msm_fbdev_init(ddev);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
#endif
|
|
|
|
|
2016-05-02 05:35:54 +00:00
|
|
|
ret = msm_debugfs_late_init(ddev);
|
2014-05-30 18:47:38 +00:00
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
|
2016-05-02 05:35:54 +00:00
|
|
|
drm_kms_helper_poll_init(ddev);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail:
|
2016-05-02 05:35:54 +00:00
|
|
|
msm_drm_uninit(dev);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-05-02 05:35:54 +00:00
|
|
|
/*
|
|
|
|
* DRM operations:
|
|
|
|
*/
|
|
|
|
|
2013-07-19 16:59:32 +00:00
|
|
|
static void load_gpu(struct drm_device *dev)
|
|
|
|
{
|
2014-07-11 15:59:22 +00:00
|
|
|
static DEFINE_MUTEX(init_lock);
|
2013-07-19 16:59:32 +00:00
|
|
|
struct msm_drm_private *priv = dev->dev_private;
|
|
|
|
|
2014-07-11 15:59:22 +00:00
|
|
|
mutex_lock(&init_lock);
|
|
|
|
|
2014-09-05 17:30:27 +00:00
|
|
|
if (!priv->gpu)
|
|
|
|
priv->gpu = adreno_load_gpu(dev);
|
2013-07-19 16:59:32 +00:00
|
|
|
|
2014-07-11 15:59:22 +00:00
|
|
|
mutex_unlock(&init_lock);
|
2013-07-19 16:59:32 +00:00
|
|
|
}
|
|
|
|
|
2017-10-20 17:06:55 +00:00
|
|
|
static int context_init(struct drm_file *file)
|
2013-07-19 16:59:32 +00:00
|
|
|
{
|
|
|
|
struct msm_file_private *ctx;
|
|
|
|
|
|
|
|
ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
|
|
|
|
if (!ctx)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2017-10-20 17:06:55 +00:00
|
|
|
msm_submitqueue_init(ctx);
|
|
|
|
|
2013-07-19 16:59:32 +00:00
|
|
|
file->driver_priv = ctx;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-10-20 17:06:55 +00:00
|
|
|
static int msm_open(struct drm_device *dev, struct drm_file *file)
|
|
|
|
{
|
|
|
|
/* For now, load gpu on open.. to avoid the requirement of having
|
|
|
|
* firmware in the initrd.
|
|
|
|
*/
|
|
|
|
load_gpu(dev);
|
|
|
|
|
|
|
|
return context_init(file);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void context_close(struct msm_file_private *ctx)
|
|
|
|
{
|
|
|
|
msm_submitqueue_close(ctx);
|
|
|
|
kfree(ctx);
|
|
|
|
}
|
|
|
|
|
2017-03-08 14:12:46 +00:00
|
|
|
static void msm_postclose(struct drm_device *dev, struct drm_file *file)
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
{
|
|
|
|
struct msm_drm_private *priv = dev->dev_private;
|
2013-07-19 16:59:32 +00:00
|
|
|
struct msm_file_private *ctx = file->driver_priv;
|
|
|
|
|
|
|
|
mutex_lock(&dev->struct_mutex);
|
|
|
|
if (ctx == priv->lastctx)
|
|
|
|
priv->lastctx = NULL;
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
2017-10-20 17:06:55 +00:00
|
|
|
context_close(ctx);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void msm_lastclose(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct msm_drm_private *priv = dev->dev_private;
|
2014-05-30 16:29:48 +00:00
|
|
|
if (priv->fbdev)
|
|
|
|
drm_fb_helper_restore_fbdev_mode_unlocked(priv->fbdev);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
}
|
|
|
|
|
2013-12-11 10:34:42 +00:00
|
|
|
static irqreturn_t msm_irq(int irq, void *arg)
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
{
|
|
|
|
struct drm_device *dev = arg;
|
|
|
|
struct msm_drm_private *priv = dev->dev_private;
|
|
|
|
struct msm_kms *kms = priv->kms;
|
|
|
|
BUG_ON(!kms);
|
|
|
|
return kms->funcs->irq(kms);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void msm_irq_preinstall(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct msm_drm_private *priv = dev->dev_private;
|
|
|
|
struct msm_kms *kms = priv->kms;
|
|
|
|
BUG_ON(!kms);
|
|
|
|
kms->funcs->irq_preinstall(kms);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int msm_irq_postinstall(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct msm_drm_private *priv = dev->dev_private;
|
|
|
|
struct msm_kms *kms = priv->kms;
|
|
|
|
BUG_ON(!kms);
|
|
|
|
return kms->funcs->irq_postinstall(kms);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void msm_irq_uninstall(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct msm_drm_private *priv = dev->dev_private;
|
|
|
|
struct msm_kms *kms = priv->kms;
|
|
|
|
BUG_ON(!kms);
|
|
|
|
kms->funcs->irq_uninstall(kms);
|
|
|
|
}
|
|
|
|
|
2015-09-24 16:35:31 +00:00
|
|
|
static int msm_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
{
|
|
|
|
struct msm_drm_private *priv = dev->dev_private;
|
|
|
|
struct msm_kms *kms = priv->kms;
|
|
|
|
if (!kms)
|
|
|
|
return -ENXIO;
|
2015-09-24 16:35:31 +00:00
|
|
|
DBG("dev=%p, crtc=%u", dev, pipe);
|
|
|
|
return vblank_ctrl_queue_work(priv, pipe, true);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
}
|
|
|
|
|
2015-09-24 16:35:31 +00:00
|
|
|
static void msm_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
{
|
|
|
|
struct msm_drm_private *priv = dev->dev_private;
|
|
|
|
struct msm_kms *kms = priv->kms;
|
|
|
|
if (!kms)
|
|
|
|
return;
|
2015-09-24 16:35:31 +00:00
|
|
|
DBG("dev=%p, crtc=%u", dev, pipe);
|
|
|
|
vblank_ctrl_queue_work(priv, pipe, false);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
}
|
|
|
|
|
2013-07-19 16:59:32 +00:00
|
|
|
/*
|
|
|
|
* DRM ioctls:
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int msm_ioctl_get_param(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
|
|
|
struct msm_drm_private *priv = dev->dev_private;
|
|
|
|
struct drm_msm_param *args = data;
|
|
|
|
struct msm_gpu *gpu;
|
|
|
|
|
|
|
|
/* for now, we just have 3d pipe.. eventually this would need to
|
|
|
|
* be more clever to dispatch to appropriate gpu module:
|
|
|
|
*/
|
|
|
|
if (args->pipe != MSM_PIPE_3D0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
gpu = priv->gpu;
|
|
|
|
|
|
|
|
if (!gpu)
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
return gpu->funcs->get_param(gpu, args->param, &args->value);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int msm_ioctl_gem_new(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
|
|
|
struct drm_msm_gem_new *args = data;
|
2014-03-03 14:42:33 +00:00
|
|
|
|
|
|
|
if (args->flags & ~MSM_BO_FLAGS) {
|
|
|
|
DRM_ERROR("invalid flags: %08x\n", args->flags);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2013-07-19 16:59:32 +00:00
|
|
|
return msm_gem_new_handle(dev, file, args->size,
|
|
|
|
args->flags, &args->handle);
|
|
|
|
}
|
|
|
|
|
2015-05-11 15:50:03 +00:00
|
|
|
static inline ktime_t to_ktime(struct drm_msm_timespec timeout)
|
|
|
|
{
|
|
|
|
return ktime_set(timeout.tv_sec, timeout.tv_nsec);
|
|
|
|
}
|
2013-07-19 16:59:32 +00:00
|
|
|
|
|
|
|
static int msm_ioctl_gem_cpu_prep(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
|
|
|
struct drm_msm_gem_cpu_prep *args = data;
|
|
|
|
struct drm_gem_object *obj;
|
2015-05-11 15:50:03 +00:00
|
|
|
ktime_t timeout = to_ktime(args->timeout);
|
2013-07-19 16:59:32 +00:00
|
|
|
int ret;
|
|
|
|
|
2014-03-03 14:42:33 +00:00
|
|
|
if (args->op & ~MSM_PREP_FLAGS) {
|
|
|
|
DRM_ERROR("invalid op: %08x\n", args->op);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-05-09 10:04:54 +00:00
|
|
|
obj = drm_gem_object_lookup(file, args->handle);
|
2013-07-19 16:59:32 +00:00
|
|
|
if (!obj)
|
|
|
|
return -ENOENT;
|
|
|
|
|
2015-05-11 15:50:03 +00:00
|
|
|
ret = msm_gem_cpu_prep(obj, args->op, &timeout);
|
2013-07-19 16:59:32 +00:00
|
|
|
|
|
|
|
drm_gem_object_unreference_unlocked(obj);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int msm_ioctl_gem_cpu_fini(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
|
|
|
struct drm_msm_gem_cpu_fini *args = data;
|
|
|
|
struct drm_gem_object *obj;
|
|
|
|
int ret;
|
|
|
|
|
2016-05-09 10:04:54 +00:00
|
|
|
obj = drm_gem_object_lookup(file, args->handle);
|
2013-07-19 16:59:32 +00:00
|
|
|
if (!obj)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
ret = msm_gem_cpu_fini(obj);
|
|
|
|
|
|
|
|
drm_gem_object_unreference_unlocked(obj);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-05-08 20:35:01 +00:00
|
|
|
static int msm_ioctl_gem_info_iova(struct drm_device *dev,
|
|
|
|
struct drm_gem_object *obj, uint64_t *iova)
|
|
|
|
{
|
|
|
|
struct msm_drm_private *priv = dev->dev_private;
|
|
|
|
|
|
|
|
if (!priv->gpu)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2017-06-13 15:07:08 +00:00
|
|
|
return msm_gem_get_iova(obj, priv->gpu->aspace, iova);
|
2017-05-08 20:35:01 +00:00
|
|
|
}
|
|
|
|
|
2013-07-19 16:59:32 +00:00
|
|
|
static int msm_ioctl_gem_info(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
|
|
|
struct drm_msm_gem_info *args = data;
|
|
|
|
struct drm_gem_object *obj;
|
|
|
|
int ret = 0;
|
|
|
|
|
2017-05-08 20:35:01 +00:00
|
|
|
if (args->flags & ~MSM_INFO_FLAGS)
|
2013-07-19 16:59:32 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2016-05-09 10:04:54 +00:00
|
|
|
obj = drm_gem_object_lookup(file, args->handle);
|
2013-07-19 16:59:32 +00:00
|
|
|
if (!obj)
|
|
|
|
return -ENOENT;
|
|
|
|
|
2017-05-08 20:35:01 +00:00
|
|
|
if (args->flags & MSM_INFO_IOVA) {
|
|
|
|
uint64_t iova;
|
|
|
|
|
|
|
|
ret = msm_ioctl_gem_info_iova(dev, obj, &iova);
|
|
|
|
if (!ret)
|
|
|
|
args->offset = iova;
|
|
|
|
} else {
|
|
|
|
args->offset = msm_gem_mmap_offset(obj);
|
|
|
|
}
|
2013-07-19 16:59:32 +00:00
|
|
|
|
|
|
|
drm_gem_object_unreference_unlocked(obj);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int msm_ioctl_wait_fence(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
2016-03-15 21:22:13 +00:00
|
|
|
struct msm_drm_private *priv = dev->dev_private;
|
2013-07-19 16:59:32 +00:00
|
|
|
struct drm_msm_wait_fence *args = data;
|
2015-05-11 15:50:03 +00:00
|
|
|
ktime_t timeout = to_ktime(args->timeout);
|
2014-03-03 14:42:33 +00:00
|
|
|
|
|
|
|
if (args->pad) {
|
|
|
|
DRM_ERROR("invalid pad: %08x\n", args->pad);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-03-15 21:22:13 +00:00
|
|
|
if (!priv->gpu)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return msm_wait_fence(priv->gpu->fctx, args->fence, &timeout, true);
|
2013-07-19 16:59:32 +00:00
|
|
|
}
|
|
|
|
|
2016-05-17 19:44:49 +00:00
|
|
|
static int msm_ioctl_gem_madvise(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
|
|
|
struct drm_msm_gem_madvise *args = data;
|
|
|
|
struct drm_gem_object *obj;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
switch (args->madv) {
|
|
|
|
case MSM_MADV_DONTNEED:
|
|
|
|
case MSM_MADV_WILLNEED:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
obj = drm_gem_object_lookup(file, args->handle);
|
|
|
|
if (!obj) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = msm_gem_madvise(obj, args->madv);
|
|
|
|
if (ret >= 0) {
|
|
|
|
args->retained = ret;
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
drm_gem_object_unreference(obj);
|
|
|
|
|
|
|
|
unlock:
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-10-20 17:06:55 +00:00
|
|
|
|
|
|
|
static int msm_ioctl_submitqueue_new(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
|
|
|
struct drm_msm_submitqueue *args = data;
|
|
|
|
|
|
|
|
if (args->flags & ~MSM_SUBMITQUEUE_FLAGS)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return msm_submitqueue_create(file->driver_priv, args->prio,
|
|
|
|
args->flags, &args->id);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int msm_ioctl_submitqueue_close(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
|
|
|
u32 id = *(u32 *) data;
|
|
|
|
|
|
|
|
return msm_submitqueue_remove(file->driver_priv, id);
|
|
|
|
}
|
|
|
|
|
2013-07-19 16:59:32 +00:00
|
|
|
static const struct drm_ioctl_desc msm_ioctls[] = {
|
2015-09-08 11:56:30 +00:00
|
|
|
DRM_IOCTL_DEF_DRV(MSM_GET_PARAM, msm_ioctl_get_param, DRM_AUTH|DRM_RENDER_ALLOW),
|
|
|
|
DRM_IOCTL_DEF_DRV(MSM_GEM_NEW, msm_ioctl_gem_new, DRM_AUTH|DRM_RENDER_ALLOW),
|
|
|
|
DRM_IOCTL_DEF_DRV(MSM_GEM_INFO, msm_ioctl_gem_info, DRM_AUTH|DRM_RENDER_ALLOW),
|
|
|
|
DRM_IOCTL_DEF_DRV(MSM_GEM_CPU_PREP, msm_ioctl_gem_cpu_prep, DRM_AUTH|DRM_RENDER_ALLOW),
|
|
|
|
DRM_IOCTL_DEF_DRV(MSM_GEM_CPU_FINI, msm_ioctl_gem_cpu_fini, DRM_AUTH|DRM_RENDER_ALLOW),
|
|
|
|
DRM_IOCTL_DEF_DRV(MSM_GEM_SUBMIT, msm_ioctl_gem_submit, DRM_AUTH|DRM_RENDER_ALLOW),
|
|
|
|
DRM_IOCTL_DEF_DRV(MSM_WAIT_FENCE, msm_ioctl_wait_fence, DRM_AUTH|DRM_RENDER_ALLOW),
|
2016-05-17 19:44:49 +00:00
|
|
|
DRM_IOCTL_DEF_DRV(MSM_GEM_MADVISE, msm_ioctl_gem_madvise, DRM_AUTH|DRM_RENDER_ALLOW),
|
2017-10-20 17:06:55 +00:00
|
|
|
DRM_IOCTL_DEF_DRV(MSM_SUBMITQUEUE_NEW, msm_ioctl_submitqueue_new, DRM_AUTH|DRM_RENDER_ALLOW),
|
|
|
|
DRM_IOCTL_DEF_DRV(MSM_SUBMITQUEUE_CLOSE, msm_ioctl_submitqueue_close, DRM_AUTH|DRM_RENDER_ALLOW),
|
2013-07-19 16:59:32 +00:00
|
|
|
};
|
|
|
|
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
static const struct vm_operations_struct vm_ops = {
|
|
|
|
.fault = msm_gem_fault,
|
|
|
|
.open = drm_gem_vm_open,
|
|
|
|
.close = drm_gem_vm_close,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct file_operations fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = drm_open,
|
|
|
|
.release = drm_release,
|
|
|
|
.unlocked_ioctl = drm_ioctl,
|
|
|
|
.compat_ioctl = drm_compat_ioctl,
|
|
|
|
.poll = drm_poll,
|
|
|
|
.read = drm_read,
|
|
|
|
.llseek = no_llseek,
|
|
|
|
.mmap = msm_gem_mmap,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct drm_driver msm_driver = {
|
2013-09-28 15:28:35 +00:00
|
|
|
.driver_features = DRIVER_HAVE_IRQ |
|
|
|
|
DRIVER_GEM |
|
|
|
|
DRIVER_PRIME |
|
2013-09-28 16:01:25 +00:00
|
|
|
DRIVER_RENDER |
|
2015-06-04 14:12:22 +00:00
|
|
|
DRIVER_ATOMIC |
|
2013-09-28 15:28:35 +00:00
|
|
|
DRIVER_MODESET,
|
2013-07-19 16:59:32 +00:00
|
|
|
.open = msm_open,
|
2017-03-08 14:12:46 +00:00
|
|
|
.postclose = msm_postclose,
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
.lastclose = msm_lastclose,
|
|
|
|
.irq_handler = msm_irq,
|
|
|
|
.irq_preinstall = msm_irq_preinstall,
|
|
|
|
.irq_postinstall = msm_irq_postinstall,
|
|
|
|
.irq_uninstall = msm_irq_uninstall,
|
|
|
|
.enable_vblank = msm_enable_vblank,
|
|
|
|
.disable_vblank = msm_disable_vblank,
|
|
|
|
.gem_free_object = msm_gem_free_object,
|
|
|
|
.gem_vm_ops = &vm_ops,
|
|
|
|
.dumb_create = msm_gem_dumb_create,
|
|
|
|
.dumb_map_offset = msm_gem_dumb_map_offset,
|
2013-09-28 15:28:35 +00:00
|
|
|
.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
|
|
|
|
.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
|
|
|
|
.gem_prime_export = drm_gem_prime_export,
|
|
|
|
.gem_prime_import = drm_gem_prime_import,
|
2017-04-12 19:11:58 +00:00
|
|
|
.gem_prime_res_obj = msm_gem_prime_res_obj,
|
2013-09-28 15:28:35 +00:00
|
|
|
.gem_prime_pin = msm_gem_prime_pin,
|
|
|
|
.gem_prime_unpin = msm_gem_prime_unpin,
|
|
|
|
.gem_prime_get_sg_table = msm_gem_prime_get_sg_table,
|
|
|
|
.gem_prime_import_sg_table = msm_gem_prime_import_sg_table,
|
|
|
|
.gem_prime_vmap = msm_gem_prime_vmap,
|
|
|
|
.gem_prime_vunmap = msm_gem_prime_vunmap,
|
2014-11-12 11:38:14 +00:00
|
|
|
.gem_prime_mmap = msm_gem_prime_mmap,
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
.debugfs_init = msm_debugfs_init,
|
|
|
|
#endif
|
2013-07-19 16:59:32 +00:00
|
|
|
.ioctls = msm_ioctls,
|
2017-05-08 20:34:59 +00:00
|
|
|
.num_ioctls = ARRAY_SIZE(msm_ioctls),
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
.fops = &fops,
|
|
|
|
.name = "msm",
|
|
|
|
.desc = "MSM Snapdragon DRM",
|
|
|
|
.date = "20130625",
|
2016-06-01 18:02:02 +00:00
|
|
|
.major = MSM_VERSION_MAJOR,
|
|
|
|
.minor = MSM_VERSION_MINOR,
|
|
|
|
.patchlevel = MSM_VERSION_PATCHLEVEL,
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
static int msm_pm_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
struct drm_device *ddev = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
drm_kms_helper_poll_disable(ddev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int msm_pm_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
struct drm_device *ddev = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
drm_kms_helper_poll_enable(ddev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
drm/msm/mdp5: Set up runtime PM for MDSS
MDSS represents the top level wrapper that contains MDP5, DSI, HDMI and
other sub-blocks. W.r.t device heirarchy, it's the parent of all these
devices. The power domain of this device is actually tied to the GDSC
hw. When any sub-device enables its PD, MDSS's PD is also enabled.
The suspend/resume ops enable the top level clocks that end at the MDSS
boundary. For now, we're letting them all be optional, since the child
devices anyway hold a ref to these clocks.
Until now, we'd called a runtime_get() during probe, which ensured that
the GDSC was always on. Now that we've set up runtime PM for the children
devices, we can get rid of this hack.
Note: that the MDSS device is the platform_device in msm_drv.c. The
msm_runtime_suspend/resume ops call the funcs that enable/disable
the top level MDSS clocks. This is different from MDP4, where the
platform device created in msm_drv.c represents MDP4 itself. It would
have been nicer to hide these differences by adding new kms funcs, but
runtime PM needs to be enabled before kms is set up (i.e, msm_kms_init
is called).
Signed-off-by: Archit Taneja <architt@codeaurora.org>
Signed-off-by: Rob Clark <robdclark@gmail.com>
2017-07-28 10:47:07 +00:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
static int msm_runtime_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
struct drm_device *ddev = dev_get_drvdata(dev);
|
|
|
|
struct msm_drm_private *priv = ddev->dev_private;
|
|
|
|
|
|
|
|
DBG("");
|
|
|
|
|
|
|
|
if (priv->mdss)
|
|
|
|
return msm_mdss_disable(priv->mdss);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int msm_runtime_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
struct drm_device *ddev = dev_get_drvdata(dev);
|
|
|
|
struct msm_drm_private *priv = ddev->dev_private;
|
|
|
|
|
|
|
|
DBG("");
|
|
|
|
|
|
|
|
if (priv->mdss)
|
|
|
|
return msm_mdss_enable(priv->mdss);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
static const struct dev_pm_ops msm_pm_ops = {
|
|
|
|
SET_SYSTEM_SLEEP_PM_OPS(msm_pm_suspend, msm_pm_resume)
|
drm/msm/mdp5: Set up runtime PM for MDSS
MDSS represents the top level wrapper that contains MDP5, DSI, HDMI and
other sub-blocks. W.r.t device heirarchy, it's the parent of all these
devices. The power domain of this device is actually tied to the GDSC
hw. When any sub-device enables its PD, MDSS's PD is also enabled.
The suspend/resume ops enable the top level clocks that end at the MDSS
boundary. For now, we're letting them all be optional, since the child
devices anyway hold a ref to these clocks.
Until now, we'd called a runtime_get() during probe, which ensured that
the GDSC was always on. Now that we've set up runtime PM for the children
devices, we can get rid of this hack.
Note: that the MDSS device is the platform_device in msm_drv.c. The
msm_runtime_suspend/resume ops call the funcs that enable/disable
the top level MDSS clocks. This is different from MDP4, where the
platform device created in msm_drv.c represents MDP4 itself. It would
have been nicer to hide these differences by adding new kms funcs, but
runtime PM needs to be enabled before kms is set up (i.e, msm_kms_init
is called).
Signed-off-by: Archit Taneja <architt@codeaurora.org>
Signed-off-by: Rob Clark <robdclark@gmail.com>
2017-07-28 10:47:07 +00:00
|
|
|
SET_RUNTIME_PM_OPS(msm_runtime_suspend, msm_runtime_resume, NULL)
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
};
|
|
|
|
|
2014-03-03 19:19:12 +00:00
|
|
|
/*
|
|
|
|
* Componentized driver support:
|
|
|
|
*/
|
|
|
|
|
2015-11-18 06:45:14 +00:00
|
|
|
/*
|
|
|
|
* NOTE: duplication of the same code as exynos or imx (or probably any other).
|
|
|
|
* so probably some room for some helpers
|
2014-03-03 19:19:12 +00:00
|
|
|
*/
|
|
|
|
static int compare_of(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
return dev->of_node == data;
|
|
|
|
}
|
2013-12-15 21:23:05 +00:00
|
|
|
|
2016-05-19 05:08:39 +00:00
|
|
|
/*
|
|
|
|
* Identify what components need to be added by parsing what remote-endpoints
|
|
|
|
* our MDP output ports are connected to. In the case of LVDS on MDP4, there
|
|
|
|
* is no external component that we need to add since LVDS is within MDP4
|
|
|
|
* itself.
|
|
|
|
*/
|
|
|
|
static int add_components_mdp(struct device *mdp_dev,
|
|
|
|
struct component_match **matchptr)
|
|
|
|
{
|
|
|
|
struct device_node *np = mdp_dev->of_node;
|
|
|
|
struct device_node *ep_node;
|
2016-06-06 08:15:34 +00:00
|
|
|
struct device *master_dev;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* on MDP4 based platforms, the MDP platform device is the component
|
|
|
|
* master that adds other display interface components to itself.
|
|
|
|
*
|
|
|
|
* on MDP5 based platforms, the MDSS platform device is the component
|
|
|
|
* master that adds MDP5 and other display interface components to
|
|
|
|
* itself.
|
|
|
|
*/
|
|
|
|
if (of_device_is_compatible(np, "qcom,mdp4"))
|
|
|
|
master_dev = mdp_dev;
|
|
|
|
else
|
|
|
|
master_dev = mdp_dev->parent;
|
2016-05-19 05:08:39 +00:00
|
|
|
|
|
|
|
for_each_endpoint_of_node(np, ep_node) {
|
|
|
|
struct device_node *intf;
|
|
|
|
struct of_endpoint ep;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = of_graph_parse_endpoint(ep_node, &ep);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(mdp_dev, "unable to parse port endpoint\n");
|
|
|
|
of_node_put(ep_node);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The LCDC/LVDS port on MDP4 is a speacial case where the
|
|
|
|
* remote-endpoint isn't a component that we need to add
|
|
|
|
*/
|
|
|
|
if (of_device_is_compatible(np, "qcom,mdp4") &&
|
2016-11-17 06:42:03 +00:00
|
|
|
ep.port == 0)
|
2016-05-19 05:08:39 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* It's okay if some of the ports don't have a remote endpoint
|
|
|
|
* specified. It just means that the port isn't connected to
|
|
|
|
* any external interface.
|
|
|
|
*/
|
|
|
|
intf = of_graph_get_remote_port_parent(ep_node);
|
2016-11-17 06:42:03 +00:00
|
|
|
if (!intf)
|
2016-05-19 05:08:39 +00:00
|
|
|
continue;
|
|
|
|
|
2016-10-19 10:28:27 +00:00
|
|
|
drm_of_component_match_add(master_dev, matchptr, compare_of,
|
|
|
|
intf);
|
2016-05-19 05:08:39 +00:00
|
|
|
of_node_put(intf);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-06-06 08:15:34 +00:00
|
|
|
static int compare_name_mdp(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
return (strstr(dev_name(dev), "mdp") != NULL);
|
|
|
|
}
|
|
|
|
|
2016-05-19 05:03:57 +00:00
|
|
|
static int add_display_components(struct device *dev,
|
|
|
|
struct component_match **matchptr)
|
|
|
|
{
|
2016-06-06 08:15:34 +00:00
|
|
|
struct device *mdp_dev;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* MDP5 based devices don't have a flat hierarchy. There is a top level
|
|
|
|
* parent: MDSS, and children: MDP5, DSI, HDMI, eDP etc. Populate the
|
|
|
|
* children devices, find the MDP5 node, and then add the interfaces
|
|
|
|
* to our components list.
|
|
|
|
*/
|
|
|
|
if (of_device_is_compatible(dev->of_node, "qcom,mdss")) {
|
|
|
|
ret = of_platform_populate(dev->of_node, NULL, NULL, dev);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(dev, "failed to populate children devices\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
mdp_dev = device_find_child(dev, NULL, compare_name_mdp);
|
|
|
|
if (!mdp_dev) {
|
|
|
|
dev_err(dev, "failed to find MDSS MDP node\n");
|
|
|
|
of_platform_depopulate(dev);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
put_device(mdp_dev);
|
|
|
|
|
|
|
|
/* add the MDP component itself */
|
2016-10-19 10:28:27 +00:00
|
|
|
drm_of_component_match_add(dev, matchptr, compare_of,
|
|
|
|
mdp_dev->of_node);
|
2016-06-06 08:15:34 +00:00
|
|
|
} else {
|
|
|
|
/* MDP4 */
|
|
|
|
mdp_dev = dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = add_components_mdp(mdp_dev, matchptr);
|
|
|
|
if (ret)
|
|
|
|
of_platform_depopulate(dev);
|
|
|
|
|
|
|
|
return ret;
|
2016-05-19 05:03:57 +00:00
|
|
|
}
|
|
|
|
|
2016-05-19 08:03:52 +00:00
|
|
|
/*
|
|
|
|
* We don't know what's the best binding to link the gpu with the drm device.
|
|
|
|
* Fow now, we just hunt for all the possible gpus that we support, and add them
|
|
|
|
* as components.
|
|
|
|
*/
|
|
|
|
static const struct of_device_id msm_gpu_match[] = {
|
2017-01-30 16:02:27 +00:00
|
|
|
{ .compatible = "qcom,adreno" },
|
2016-05-19 08:03:52 +00:00
|
|
|
{ .compatible = "qcom,adreno-3xx" },
|
|
|
|
{ .compatible = "qcom,kgsl-3d0" },
|
|
|
|
{ },
|
|
|
|
};
|
|
|
|
|
2016-05-19 05:03:57 +00:00
|
|
|
static int add_gpu_components(struct device *dev,
|
|
|
|
struct component_match **matchptr)
|
|
|
|
{
|
2016-05-19 08:03:52 +00:00
|
|
|
struct device_node *np;
|
|
|
|
|
|
|
|
np = of_find_matching_node(NULL, msm_gpu_match);
|
|
|
|
if (!np)
|
|
|
|
return 0;
|
|
|
|
|
2016-10-19 10:28:27 +00:00
|
|
|
drm_of_component_match_add(dev, matchptr, compare_of, np);
|
2016-05-19 08:03:52 +00:00
|
|
|
|
|
|
|
of_node_put(np);
|
|
|
|
|
|
|
|
return 0;
|
2016-05-19 05:03:57 +00:00
|
|
|
}
|
|
|
|
|
2014-04-19 10:20:42 +00:00
|
|
|
static int msm_drm_bind(struct device *dev)
|
|
|
|
{
|
2016-05-02 05:35:54 +00:00
|
|
|
return msm_drm_init(dev, &msm_driver);
|
2014-04-19 10:20:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void msm_drm_unbind(struct device *dev)
|
|
|
|
{
|
2016-05-02 05:35:54 +00:00
|
|
|
msm_drm_uninit(dev);
|
2014-04-19 10:20:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct component_master_ops msm_drm_ops = {
|
|
|
|
.bind = msm_drm_bind,
|
|
|
|
.unbind = msm_drm_unbind,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Platform driver:
|
|
|
|
*/
|
2014-03-03 19:19:12 +00:00
|
|
|
|
2014-04-19 10:20:42 +00:00
|
|
|
static int msm_pdev_probe(struct platform_device *pdev)
|
2014-03-03 19:19:12 +00:00
|
|
|
{
|
2014-04-19 10:20:42 +00:00
|
|
|
struct component_match *match = NULL;
|
2016-05-19 05:03:57 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = add_display_components(&pdev->dev, &match);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2015-11-18 06:45:14 +00:00
|
|
|
|
2016-05-19 05:03:57 +00:00
|
|
|
ret = add_gpu_components(&pdev->dev, &match);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2014-03-03 19:19:12 +00:00
|
|
|
|
2016-11-07 18:31:30 +00:00
|
|
|
/* on all devices that I am aware of, iommu's which can map
|
|
|
|
* any address the cpu can see are used:
|
|
|
|
*/
|
|
|
|
ret = dma_set_mask_and_coherent(&pdev->dev, ~0);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2014-04-19 10:20:42 +00:00
|
|
|
return component_master_add_with_match(&pdev->dev, &msm_drm_ops, match);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int msm_pdev_remove(struct platform_device *pdev)
|
|
|
|
{
|
2014-03-03 19:19:12 +00:00
|
|
|
component_master_del(&pdev->dev, &msm_drm_ops);
|
2016-06-06 08:15:34 +00:00
|
|
|
of_platform_depopulate(&pdev->dev);
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
drm/msm: add mdp5/apq8x74
Add support for the new MDP5 display controller block. The mapping
between parts of the display controller and KMS is:
plane -> PIPE{RGBn,VIGn} \
crtc -> LM (layer mixer) |-> MDP "device"
encoder -> INTF /
connector -> HDMI/DSI/eDP/etc --> other device(s)
Unlike MDP4, it appears we can get by with a single encoder, rather
than needing a different implementation for DTV, DSI, etc. (Ie. the
register interface is same, just different bases.)
Also unlike MDP4, all the IRQs for other blocks (HDMI, DSI, etc) are
routed through MDP.
And finally, MDP5 has this "Shared Memory Pool" (called "SMP"), from
which blocks need to be allocated to the active pipes based on fetch
stride.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-11-30 22:51:47 +00:00
|
|
|
static const struct of_device_id dt_match[] = {
|
2016-05-30 11:32:00 +00:00
|
|
|
{ .compatible = "qcom,mdp4", .data = (void *)4 }, /* MDP4 */
|
|
|
|
{ .compatible = "qcom,mdss", .data = (void *)5 }, /* MDP5 MDSS */
|
drm/msm: add mdp5/apq8x74
Add support for the new MDP5 display controller block. The mapping
between parts of the display controller and KMS is:
plane -> PIPE{RGBn,VIGn} \
crtc -> LM (layer mixer) |-> MDP "device"
encoder -> INTF /
connector -> HDMI/DSI/eDP/etc --> other device(s)
Unlike MDP4, it appears we can get by with a single encoder, rather
than needing a different implementation for DTV, DSI, etc. (Ie. the
register interface is same, just different bases.)
Also unlike MDP4, all the IRQs for other blocks (HDMI, DSI, etc) are
routed through MDP.
And finally, MDP5 has this "Shared Memory Pool" (called "SMP"), from
which blocks need to be allocated to the active pipes based on fetch
stride.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-11-30 22:51:47 +00:00
|
|
|
{}
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, dt_match);
|
|
|
|
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
static struct platform_driver msm_platform_driver = {
|
|
|
|
.probe = msm_pdev_probe,
|
|
|
|
.remove = msm_pdev_remove,
|
|
|
|
.driver = {
|
|
|
|
.name = "msm",
|
drm/msm: add mdp5/apq8x74
Add support for the new MDP5 display controller block. The mapping
between parts of the display controller and KMS is:
plane -> PIPE{RGBn,VIGn} \
crtc -> LM (layer mixer) |-> MDP "device"
encoder -> INTF /
connector -> HDMI/DSI/eDP/etc --> other device(s)
Unlike MDP4, it appears we can get by with a single encoder, rather
than needing a different implementation for DTV, DSI, etc. (Ie. the
register interface is same, just different bases.)
Also unlike MDP4, all the IRQs for other blocks (HDMI, DSI, etc) are
routed through MDP.
And finally, MDP5 has this "Shared Memory Pool" (called "SMP"), from
which blocks need to be allocated to the active pipes based on fetch
stride.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-11-30 22:51:47 +00:00
|
|
|
.of_match_table = dt_match,
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
.pm = &msm_pm_ops,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init msm_drm_register(void)
|
|
|
|
{
|
2017-07-06 20:33:44 +00:00
|
|
|
if (!modeset)
|
|
|
|
return -EINVAL;
|
|
|
|
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
DBG("init");
|
drm/msm/mdp5: Create a separate MDP5 device
In order to have a tree-like device hierarchy between MDSS and its
sub-blocks (MDP5, DSI, HDMI, eDP etc), we need to create a separate
device/driver for MDP5. Currently, MDP5 and MDSS are squashed
together are are tied to the top level platform_device, which is
also the one used to create drm_device.
The mdp5_kms_init code is split into two parts. The part where device
resources are allocated are associated with the MDP5 driver's probe,
the rest is executed later when we initialize modeset.
With this change, unlike MDP4, the MDP5 platform_device isn't tied to
the top level drm_device anymore. The top level drm_device is now
associated with a platform device that corresponds to MDSS wrapper
hardware.
Create mdp5_init/destroy funcs that will be used by the MDP5 driver
probe/remove. Use the HW_VERSION register in the MDP5 register address
space. Both the MDSS and MDP VERSION registers give out identical
version info.
The older mdp5_kms_init code is left as is for now, this would be removed
later when we have all the pieces to support the new device hierarchy.
Signed-off-by: Archit Taneja <architt@codeaurora.org>
Signed-off-by: Rob Clark <robdclark@gmail.com>
2016-05-30 11:06:50 +00:00
|
|
|
msm_mdp_register();
|
2015-03-26 23:25:17 +00:00
|
|
|
msm_dsi_register();
|
2014-12-12 19:41:17 +00:00
|
|
|
msm_edp_register();
|
2016-02-22 21:08:35 +00:00
|
|
|
msm_hdmi_register();
|
2014-09-05 17:06:37 +00:00
|
|
|
adreno_register();
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
return platform_driver_register(&msm_platform_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit msm_drm_unregister(void)
|
|
|
|
{
|
|
|
|
DBG("fini");
|
|
|
|
platform_driver_unregister(&msm_platform_driver);
|
2016-02-22 21:08:35 +00:00
|
|
|
msm_hdmi_unregister();
|
2014-09-05 17:06:37 +00:00
|
|
|
adreno_unregister();
|
2014-12-12 19:41:17 +00:00
|
|
|
msm_edp_unregister();
|
2015-03-26 23:25:17 +00:00
|
|
|
msm_dsi_unregister();
|
drm/msm/mdp5: Create a separate MDP5 device
In order to have a tree-like device hierarchy between MDSS and its
sub-blocks (MDP5, DSI, HDMI, eDP etc), we need to create a separate
device/driver for MDP5. Currently, MDP5 and MDSS are squashed
together are are tied to the top level platform_device, which is
also the one used to create drm_device.
The mdp5_kms_init code is split into two parts. The part where device
resources are allocated are associated with the MDP5 driver's probe,
the rest is executed later when we initialize modeset.
With this change, unlike MDP4, the MDP5 platform_device isn't tied to
the top level drm_device anymore. The top level drm_device is now
associated with a platform device that corresponds to MDSS wrapper
hardware.
Create mdp5_init/destroy funcs that will be used by the MDP5 driver
probe/remove. Use the HW_VERSION register in the MDP5 register address
space. Both the MDSS and MDP VERSION registers give out identical
version info.
The older mdp5_kms_init code is left as is for now, this would be removed
later when we have all the pieces to support the new device hierarchy.
Signed-off-by: Archit Taneja <architt@codeaurora.org>
Signed-off-by: Rob Clark <robdclark@gmail.com>
2016-05-30 11:06:50 +00:00
|
|
|
msm_mdp_unregister();
|
drm/msm: basic KMS driver for snapdragon
The snapdragon chips have multiple different display controllers,
depending on which chip variant/version. (As far as I can tell, current
devices have either MDP3 or MDP4, and upcoming devices have MDSS.) And
then external to the display controller are HDMI, DSI, etc. blocks which
may be shared across devices which have different display controller
blocks.
To more easily add support for different display controller blocks, the
display controller specific bits are split out into a "kms" module,
which provides the kms plane/crtc/encoder objects.
The external HDMI, DSI, etc. blocks are part encoder, and part connector
currently. But I think I will pull in the drm_bridge patches from
chromeos tree, and split them into a bridge+connector, with the
registers that need to be set in modeset handled by the bridge. This
would remove the 'msm_connector' base class. But some things need to be
double checked to make sure I could get the correct ON/OFF sequencing..
This patch adds support for mdp4 crtc (including hw cursor), dtv encoder
(part of MDP4 block), and hdmi.
Signed-off-by: Rob Clark <robdclark@gmail.com>
2013-06-26 16:44:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(msm_drm_register);
|
|
|
|
module_exit(msm_drm_unregister);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Rob Clark <robdclark@gmail.com");
|
|
|
|
MODULE_DESCRIPTION("MSM DRM Driver");
|
|
|
|
MODULE_LICENSE("GPL");
|