2009-12-11 16:24:15 +07:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2008 Maarten Maathuis.
|
|
|
|
* All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
|
|
* a copy of this software and associated documentation files (the
|
|
|
|
* "Software"), to deal in the Software without restriction, including
|
|
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
|
|
* the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the
|
|
|
|
* next paragraph) shall be included in all copies or substantial
|
|
|
|
* portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
|
|
* IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
|
|
|
|
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
|
|
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
|
|
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2016-11-10 00:17:44 +07:00
|
|
|
#include <acpi/video.h>
|
2012-10-03 00:01:07 +07:00
|
|
|
#include <drm/drmP.h>
|
2016-11-04 14:20:36 +07:00
|
|
|
#include <drm/drm_atomic.h>
|
|
|
|
#include <drm/drm_atomic_helper.h>
|
2012-10-03 00:01:07 +07:00
|
|
|
#include <drm/drm_crtc_helper.h>
|
2012-07-31 13:16:21 +07:00
|
|
|
|
2014-08-10 01:10:23 +07:00
|
|
|
#include <nvif/class.h>
|
|
|
|
|
2009-12-11 16:24:15 +07:00
|
|
|
#include "nouveau_fbcon.h"
|
2013-03-21 12:45:11 +07:00
|
|
|
#include "dispnv04/hw.h"
|
2010-10-21 04:35:40 +07:00
|
|
|
#include "nouveau_crtc.h"
|
|
|
|
#include "nouveau_dma.h"
|
2012-07-31 13:16:21 +07:00
|
|
|
#include "nouveau_gem.h"
|
2011-10-17 09:23:41 +07:00
|
|
|
#include "nouveau_connector.h"
|
2011-02-09 08:57:45 +07:00
|
|
|
#include "nv50_display.h"
|
2009-12-11 16:24:15 +07:00
|
|
|
|
2012-07-20 05:17:34 +07:00
|
|
|
#include "nouveau_fence.h"
|
|
|
|
|
2015-11-08 07:44:19 +07:00
|
|
|
#include <nvif/cl0046.h>
|
2014-08-10 01:10:20 +07:00
|
|
|
#include <nvif/event.h>
|
2013-01-31 06:23:34 +07:00
|
|
|
|
2013-10-03 04:02:29 +07:00
|
|
|
static int
|
2014-08-10 01:10:28 +07:00
|
|
|
nouveau_display_vblank_handler(struct nvif_notify *notify)
|
2013-10-03 04:02:29 +07:00
|
|
|
{
|
2014-08-10 01:10:20 +07:00
|
|
|
struct nouveau_crtc *nv_crtc =
|
|
|
|
container_of(notify, typeof(*nv_crtc), vblank);
|
2016-07-05 07:04:50 +07:00
|
|
|
drm_crtc_handle_vblank(&nv_crtc->base);
|
2014-08-10 01:10:28 +07:00
|
|
|
return NVIF_NOTIFY_KEEP;
|
2013-10-03 04:02:29 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2015-09-24 23:35:31 +07:00
|
|
|
nouveau_display_vblank_enable(struct drm_device *dev, unsigned int pipe)
|
2013-10-03 04:02:29 +07:00
|
|
|
{
|
2014-08-10 01:10:19 +07:00
|
|
|
struct drm_crtc *crtc;
|
2017-01-09 18:25:43 +07:00
|
|
|
struct nouveau_crtc *nv_crtc;
|
|
|
|
|
|
|
|
crtc = drm_crtc_from_index(dev, pipe);
|
|
|
|
if (!crtc)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
nv_crtc = nouveau_crtc(crtc);
|
|
|
|
nvif_notify_get(&nv_crtc->vblank);
|
|
|
|
|
|
|
|
return 0;
|
2013-10-03 04:02:29 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2015-09-24 23:35:31 +07:00
|
|
|
nouveau_display_vblank_disable(struct drm_device *dev, unsigned int pipe)
|
2013-10-03 04:02:29 +07:00
|
|
|
{
|
2014-08-10 01:10:19 +07:00
|
|
|
struct drm_crtc *crtc;
|
2017-01-09 18:25:43 +07:00
|
|
|
struct nouveau_crtc *nv_crtc;
|
|
|
|
|
|
|
|
crtc = drm_crtc_from_index(dev, pipe);
|
|
|
|
if (!crtc)
|
|
|
|
return;
|
|
|
|
|
|
|
|
nv_crtc = nouveau_crtc(crtc);
|
|
|
|
nvif_notify_put(&nv_crtc->vblank);
|
2013-10-03 04:02:29 +07:00
|
|
|
}
|
|
|
|
|
2013-11-14 10:37:49 +07:00
|
|
|
static inline int
|
|
|
|
calc(int blanks, int blanke, int total, int line)
|
|
|
|
{
|
|
|
|
if (blanke >= blanks) {
|
|
|
|
if (line >= blanks)
|
|
|
|
line -= total;
|
|
|
|
} else {
|
|
|
|
if (line >= blanks)
|
|
|
|
line -= total;
|
|
|
|
line -= blanke + 1;
|
|
|
|
}
|
|
|
|
return line;
|
|
|
|
}
|
|
|
|
|
drm/vblank: drop the mode argument from drm_calc_vbltimestamp_from_scanoutpos
If we restrict this helper to only kms drivers (which is the case) we
can look up the correct mode easily ourselves. But it's a bit tricky:
- All legacy drivers look at crtc->hwmode. But that is updated already
at the beginning of the modeset helper, which means when we disable
a pipe. Hence the final timestamps might be a bit off. But since
this is an existing bug I'm not going to change it, but just try to
be bug-for-bug compatible with the current code. This only applies
to radeon&amdgpu.
- i915 tries to get it perfect by updating crtc->hwmode when the pipe
is off (i.e. vblank->enabled = false).
- All other atomic drivers look at crtc->state->adjusted_mode. Those
that look at state->requested_mode simply don't adjust their mode,
so it's the same. That has two problems: Accessing crtc->state from
interrupt handling code is unsafe, and it's updated before we shut
down the pipe. For nonblocking modesets it's even worse.
For atomic drivers try to implement what i915 does. To do that we add
a new hwmode field to the vblank structure, and update it from
drm_calc_timestamping_constants(). For atomic drivers that's called
from the right spot by the helper library already, so all fine. But
for safety let's enforce that.
For legacy driver this function is only called at the end (oh the
fun), which is broken, so again let's not bother and just stay
bug-for-bug compatible.
The benefit is that we can use drm_calc_vbltimestamp_from_scanoutpos
directly to implement ->get_vblank_timestamp in every driver, deleting
a lot of code.
v2: Completely new approach, trying to mimick the i915 solution.
v3: Fixup kerneldoc.
v4: Drop the WARN_ON to check that the vblank is off, atomic helpers
currently unconditionally call this. Recomputing the same stuff should
be harmless.
v5: Fix typos and move misplaced hunks to the right patches (Neil).
v6: Undo hunk movement (kbuild).
Cc: Mario Kleiner <mario.kleiner@tuebingen.mpg.de>
Cc: Eric Anholt <eric@anholt.net>
Cc: Rob Clark <robdclark@gmail.com>
Cc: linux-arm-msm@vger.kernel.org
Cc: freedreno@lists.freedesktop.org
Cc: Alex Deucher <alexander.deucher@amd.com>
Cc: Christian König <christian.koenig@amd.com>
Cc: Ben Skeggs <bskeggs@redhat.com>
Reviewed-by: Neil Armstrong <narmstrong@baylibre.com>
Acked-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20170509140329.24114-4-daniel.vetter@ffwll.ch
2017-05-09 21:03:28 +07:00
|
|
|
static bool
|
2013-11-14 10:37:49 +07:00
|
|
|
nouveau_display_scanoutpos_head(struct drm_crtc *crtc, int *vpos, int *hpos,
|
|
|
|
ktime_t *stime, ktime_t *etime)
|
|
|
|
{
|
2014-08-10 01:10:27 +07:00
|
|
|
struct {
|
|
|
|
struct nv04_disp_mthd_v0 base;
|
|
|
|
struct nv04_disp_scanoutpos_v0 scan;
|
|
|
|
} args = {
|
|
|
|
.base.method = NV04_DISP_SCANOUTPOS,
|
|
|
|
.base.head = nouveau_crtc(crtc)->index,
|
|
|
|
};
|
2013-11-14 10:37:49 +07:00
|
|
|
struct nouveau_display *disp = nouveau_display(crtc->dev);
|
2015-09-15 02:43:43 +07:00
|
|
|
struct drm_vblank_crtc *vblank = &crtc->dev->vblank[drm_crtc_index(crtc)];
|
drm/vblank: drop the mode argument from drm_calc_vbltimestamp_from_scanoutpos
If we restrict this helper to only kms drivers (which is the case) we
can look up the correct mode easily ourselves. But it's a bit tricky:
- All legacy drivers look at crtc->hwmode. But that is updated already
at the beginning of the modeset helper, which means when we disable
a pipe. Hence the final timestamps might be a bit off. But since
this is an existing bug I'm not going to change it, but just try to
be bug-for-bug compatible with the current code. This only applies
to radeon&amdgpu.
- i915 tries to get it perfect by updating crtc->hwmode when the pipe
is off (i.e. vblank->enabled = false).
- All other atomic drivers look at crtc->state->adjusted_mode. Those
that look at state->requested_mode simply don't adjust their mode,
so it's the same. That has two problems: Accessing crtc->state from
interrupt handling code is unsafe, and it's updated before we shut
down the pipe. For nonblocking modesets it's even worse.
For atomic drivers try to implement what i915 does. To do that we add
a new hwmode field to the vblank structure, and update it from
drm_calc_timestamping_constants(). For atomic drivers that's called
from the right spot by the helper library already, so all fine. But
for safety let's enforce that.
For legacy driver this function is only called at the end (oh the
fun), which is broken, so again let's not bother and just stay
bug-for-bug compatible.
The benefit is that we can use drm_calc_vbltimestamp_from_scanoutpos
directly to implement ->get_vblank_timestamp in every driver, deleting
a lot of code.
v2: Completely new approach, trying to mimick the i915 solution.
v3: Fixup kerneldoc.
v4: Drop the WARN_ON to check that the vblank is off, atomic helpers
currently unconditionally call this. Recomputing the same stuff should
be harmless.
v5: Fix typos and move misplaced hunks to the right patches (Neil).
v6: Undo hunk movement (kbuild).
Cc: Mario Kleiner <mario.kleiner@tuebingen.mpg.de>
Cc: Eric Anholt <eric@anholt.net>
Cc: Rob Clark <robdclark@gmail.com>
Cc: linux-arm-msm@vger.kernel.org
Cc: freedreno@lists.freedesktop.org
Cc: Alex Deucher <alexander.deucher@amd.com>
Cc: Christian König <christian.koenig@amd.com>
Cc: Ben Skeggs <bskeggs@redhat.com>
Reviewed-by: Neil Armstrong <narmstrong@baylibre.com>
Acked-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20170509140329.24114-4-daniel.vetter@ffwll.ch
2017-05-09 21:03:28 +07:00
|
|
|
int retry = 20;
|
|
|
|
bool ret = false;
|
2013-11-14 10:37:49 +07:00
|
|
|
|
|
|
|
do {
|
2014-08-10 01:10:27 +07:00
|
|
|
ret = nvif_mthd(&disp->disp, 0, &args, sizeof(args));
|
2013-11-14 10:37:49 +07:00
|
|
|
if (ret != 0)
|
drm/vblank: drop the mode argument from drm_calc_vbltimestamp_from_scanoutpos
If we restrict this helper to only kms drivers (which is the case) we
can look up the correct mode easily ourselves. But it's a bit tricky:
- All legacy drivers look at crtc->hwmode. But that is updated already
at the beginning of the modeset helper, which means when we disable
a pipe. Hence the final timestamps might be a bit off. But since
this is an existing bug I'm not going to change it, but just try to
be bug-for-bug compatible with the current code. This only applies
to radeon&amdgpu.
- i915 tries to get it perfect by updating crtc->hwmode when the pipe
is off (i.e. vblank->enabled = false).
- All other atomic drivers look at crtc->state->adjusted_mode. Those
that look at state->requested_mode simply don't adjust their mode,
so it's the same. That has two problems: Accessing crtc->state from
interrupt handling code is unsafe, and it's updated before we shut
down the pipe. For nonblocking modesets it's even worse.
For atomic drivers try to implement what i915 does. To do that we add
a new hwmode field to the vblank structure, and update it from
drm_calc_timestamping_constants(). For atomic drivers that's called
from the right spot by the helper library already, so all fine. But
for safety let's enforce that.
For legacy driver this function is only called at the end (oh the
fun), which is broken, so again let's not bother and just stay
bug-for-bug compatible.
The benefit is that we can use drm_calc_vbltimestamp_from_scanoutpos
directly to implement ->get_vblank_timestamp in every driver, deleting
a lot of code.
v2: Completely new approach, trying to mimick the i915 solution.
v3: Fixup kerneldoc.
v4: Drop the WARN_ON to check that the vblank is off, atomic helpers
currently unconditionally call this. Recomputing the same stuff should
be harmless.
v5: Fix typos and move misplaced hunks to the right patches (Neil).
v6: Undo hunk movement (kbuild).
Cc: Mario Kleiner <mario.kleiner@tuebingen.mpg.de>
Cc: Eric Anholt <eric@anholt.net>
Cc: Rob Clark <robdclark@gmail.com>
Cc: linux-arm-msm@vger.kernel.org
Cc: freedreno@lists.freedesktop.org
Cc: Alex Deucher <alexander.deucher@amd.com>
Cc: Christian König <christian.koenig@amd.com>
Cc: Ben Skeggs <bskeggs@redhat.com>
Reviewed-by: Neil Armstrong <narmstrong@baylibre.com>
Acked-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20170509140329.24114-4-daniel.vetter@ffwll.ch
2017-05-09 21:03:28 +07:00
|
|
|
return false;
|
2013-11-14 10:37:49 +07:00
|
|
|
|
2014-08-10 01:10:27 +07:00
|
|
|
if (args.scan.vline) {
|
drm/vblank: drop the mode argument from drm_calc_vbltimestamp_from_scanoutpos
If we restrict this helper to only kms drivers (which is the case) we
can look up the correct mode easily ourselves. But it's a bit tricky:
- All legacy drivers look at crtc->hwmode. But that is updated already
at the beginning of the modeset helper, which means when we disable
a pipe. Hence the final timestamps might be a bit off. But since
this is an existing bug I'm not going to change it, but just try to
be bug-for-bug compatible with the current code. This only applies
to radeon&amdgpu.
- i915 tries to get it perfect by updating crtc->hwmode when the pipe
is off (i.e. vblank->enabled = false).
- All other atomic drivers look at crtc->state->adjusted_mode. Those
that look at state->requested_mode simply don't adjust their mode,
so it's the same. That has two problems: Accessing crtc->state from
interrupt handling code is unsafe, and it's updated before we shut
down the pipe. For nonblocking modesets it's even worse.
For atomic drivers try to implement what i915 does. To do that we add
a new hwmode field to the vblank structure, and update it from
drm_calc_timestamping_constants(). For atomic drivers that's called
from the right spot by the helper library already, so all fine. But
for safety let's enforce that.
For legacy driver this function is only called at the end (oh the
fun), which is broken, so again let's not bother and just stay
bug-for-bug compatible.
The benefit is that we can use drm_calc_vbltimestamp_from_scanoutpos
directly to implement ->get_vblank_timestamp in every driver, deleting
a lot of code.
v2: Completely new approach, trying to mimick the i915 solution.
v3: Fixup kerneldoc.
v4: Drop the WARN_ON to check that the vblank is off, atomic helpers
currently unconditionally call this. Recomputing the same stuff should
be harmless.
v5: Fix typos and move misplaced hunks to the right patches (Neil).
v6: Undo hunk movement (kbuild).
Cc: Mario Kleiner <mario.kleiner@tuebingen.mpg.de>
Cc: Eric Anholt <eric@anholt.net>
Cc: Rob Clark <robdclark@gmail.com>
Cc: linux-arm-msm@vger.kernel.org
Cc: freedreno@lists.freedesktop.org
Cc: Alex Deucher <alexander.deucher@amd.com>
Cc: Christian König <christian.koenig@amd.com>
Cc: Ben Skeggs <bskeggs@redhat.com>
Reviewed-by: Neil Armstrong <narmstrong@baylibre.com>
Acked-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20170509140329.24114-4-daniel.vetter@ffwll.ch
2017-05-09 21:03:28 +07:00
|
|
|
ret = true;
|
2013-11-14 10:37:49 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2015-09-15 02:43:43 +07:00
|
|
|
if (retry) ndelay(vblank->linedur_ns);
|
2013-11-14 10:37:49 +07:00
|
|
|
} while (retry--);
|
|
|
|
|
2014-08-10 01:10:27 +07:00
|
|
|
*hpos = args.scan.hline;
|
|
|
|
*vpos = calc(args.scan.vblanks, args.scan.vblanke,
|
|
|
|
args.scan.vtotal, args.scan.vline);
|
|
|
|
if (stime) *stime = ns_to_ktime(args.scan.time[0]);
|
|
|
|
if (etime) *etime = ns_to_ktime(args.scan.time[1]);
|
2013-11-14 10:37:49 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
drm/vblank: drop the mode argument from drm_calc_vbltimestamp_from_scanoutpos
If we restrict this helper to only kms drivers (which is the case) we
can look up the correct mode easily ourselves. But it's a bit tricky:
- All legacy drivers look at crtc->hwmode. But that is updated already
at the beginning of the modeset helper, which means when we disable
a pipe. Hence the final timestamps might be a bit off. But since
this is an existing bug I'm not going to change it, but just try to
be bug-for-bug compatible with the current code. This only applies
to radeon&amdgpu.
- i915 tries to get it perfect by updating crtc->hwmode when the pipe
is off (i.e. vblank->enabled = false).
- All other atomic drivers look at crtc->state->adjusted_mode. Those
that look at state->requested_mode simply don't adjust their mode,
so it's the same. That has two problems: Accessing crtc->state from
interrupt handling code is unsafe, and it's updated before we shut
down the pipe. For nonblocking modesets it's even worse.
For atomic drivers try to implement what i915 does. To do that we add
a new hwmode field to the vblank structure, and update it from
drm_calc_timestamping_constants(). For atomic drivers that's called
from the right spot by the helper library already, so all fine. But
for safety let's enforce that.
For legacy driver this function is only called at the end (oh the
fun), which is broken, so again let's not bother and just stay
bug-for-bug compatible.
The benefit is that we can use drm_calc_vbltimestamp_from_scanoutpos
directly to implement ->get_vblank_timestamp in every driver, deleting
a lot of code.
v2: Completely new approach, trying to mimick the i915 solution.
v3: Fixup kerneldoc.
v4: Drop the WARN_ON to check that the vblank is off, atomic helpers
currently unconditionally call this. Recomputing the same stuff should
be harmless.
v5: Fix typos and move misplaced hunks to the right patches (Neil).
v6: Undo hunk movement (kbuild).
Cc: Mario Kleiner <mario.kleiner@tuebingen.mpg.de>
Cc: Eric Anholt <eric@anholt.net>
Cc: Rob Clark <robdclark@gmail.com>
Cc: linux-arm-msm@vger.kernel.org
Cc: freedreno@lists.freedesktop.org
Cc: Alex Deucher <alexander.deucher@amd.com>
Cc: Christian König <christian.koenig@amd.com>
Cc: Ben Skeggs <bskeggs@redhat.com>
Reviewed-by: Neil Armstrong <narmstrong@baylibre.com>
Acked-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20170509140329.24114-4-daniel.vetter@ffwll.ch
2017-05-09 21:03:28 +07:00
|
|
|
bool
|
2015-09-24 23:35:31 +07:00
|
|
|
nouveau_display_scanoutpos(struct drm_device *dev, unsigned int pipe,
|
drm/vblank: drop the mode argument from drm_calc_vbltimestamp_from_scanoutpos
If we restrict this helper to only kms drivers (which is the case) we
can look up the correct mode easily ourselves. But it's a bit tricky:
- All legacy drivers look at crtc->hwmode. But that is updated already
at the beginning of the modeset helper, which means when we disable
a pipe. Hence the final timestamps might be a bit off. But since
this is an existing bug I'm not going to change it, but just try to
be bug-for-bug compatible with the current code. This only applies
to radeon&amdgpu.
- i915 tries to get it perfect by updating crtc->hwmode when the pipe
is off (i.e. vblank->enabled = false).
- All other atomic drivers look at crtc->state->adjusted_mode. Those
that look at state->requested_mode simply don't adjust their mode,
so it's the same. That has two problems: Accessing crtc->state from
interrupt handling code is unsafe, and it's updated before we shut
down the pipe. For nonblocking modesets it's even worse.
For atomic drivers try to implement what i915 does. To do that we add
a new hwmode field to the vblank structure, and update it from
drm_calc_timestamping_constants(). For atomic drivers that's called
from the right spot by the helper library already, so all fine. But
for safety let's enforce that.
For legacy driver this function is only called at the end (oh the
fun), which is broken, so again let's not bother and just stay
bug-for-bug compatible.
The benefit is that we can use drm_calc_vbltimestamp_from_scanoutpos
directly to implement ->get_vblank_timestamp in every driver, deleting
a lot of code.
v2: Completely new approach, trying to mimick the i915 solution.
v3: Fixup kerneldoc.
v4: Drop the WARN_ON to check that the vblank is off, atomic helpers
currently unconditionally call this. Recomputing the same stuff should
be harmless.
v5: Fix typos and move misplaced hunks to the right patches (Neil).
v6: Undo hunk movement (kbuild).
Cc: Mario Kleiner <mario.kleiner@tuebingen.mpg.de>
Cc: Eric Anholt <eric@anholt.net>
Cc: Rob Clark <robdclark@gmail.com>
Cc: linux-arm-msm@vger.kernel.org
Cc: freedreno@lists.freedesktop.org
Cc: Alex Deucher <alexander.deucher@amd.com>
Cc: Christian König <christian.koenig@amd.com>
Cc: Ben Skeggs <bskeggs@redhat.com>
Reviewed-by: Neil Armstrong <narmstrong@baylibre.com>
Acked-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20170509140329.24114-4-daniel.vetter@ffwll.ch
2017-05-09 21:03:28 +07:00
|
|
|
bool in_vblank_irq, int *vpos, int *hpos,
|
2015-09-24 23:35:31 +07:00
|
|
|
ktime_t *stime, ktime_t *etime,
|
2015-09-15 02:43:44 +07:00
|
|
|
const struct drm_display_mode *mode)
|
2013-11-14 10:37:49 +07:00
|
|
|
{
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
2015-09-24 23:35:31 +07:00
|
|
|
if (nouveau_crtc(crtc)->index == pipe) {
|
2013-11-14 10:37:49 +07:00
|
|
|
return nouveau_display_scanoutpos_head(crtc, vpos, hpos,
|
|
|
|
stime, etime);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-09 21:03:25 +07:00
|
|
|
return false;
|
2013-11-14 10:37:49 +07:00
|
|
|
}
|
|
|
|
|
2013-10-03 04:02:29 +07:00
|
|
|
static void
|
|
|
|
nouveau_display_vblank_fini(struct drm_device *dev)
|
|
|
|
{
|
2014-08-10 01:10:19 +07:00
|
|
|
struct drm_crtc *crtc;
|
2013-10-03 04:02:29 +07:00
|
|
|
|
2014-01-23 07:49:47 +07:00
|
|
|
drm_vblank_cleanup(dev);
|
|
|
|
|
2014-08-10 01:10:19 +07:00
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
|
2014-08-10 01:10:28 +07:00
|
|
|
nvif_notify_fini(&nv_crtc->vblank);
|
2013-10-03 04:02:29 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
nouveau_display_vblank_init(struct drm_device *dev)
|
|
|
|
{
|
2014-08-10 01:10:28 +07:00
|
|
|
struct nouveau_display *disp = nouveau_display(dev);
|
2014-08-10 01:10:19 +07:00
|
|
|
struct drm_crtc *crtc;
|
|
|
|
int ret;
|
2013-10-03 04:02:29 +07:00
|
|
|
|
2014-08-10 01:10:19 +07:00
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
|
2015-08-20 11:54:15 +07:00
|
|
|
ret = nvif_notify_init(&disp->disp,
|
2014-08-10 01:10:20 +07:00
|
|
|
nouveau_display_vblank_handler, false,
|
2014-08-10 01:10:28 +07:00
|
|
|
NV04_DISP_NTFY_VBLANK,
|
2014-08-10 01:10:20 +07:00
|
|
|
&(struct nvif_notify_head_req_v0) {
|
|
|
|
.head = nv_crtc->index,
|
|
|
|
},
|
|
|
|
sizeof(struct nvif_notify_head_req_v0),
|
|
|
|
sizeof(struct nvif_notify_head_rep_v0),
|
|
|
|
&nv_crtc->vblank);
|
2013-10-03 04:02:29 +07:00
|
|
|
if (ret) {
|
|
|
|
nouveau_display_vblank_fini(dev);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = drm_vblank_init(dev, dev->mode_config.num_crtc);
|
|
|
|
if (ret) {
|
|
|
|
nouveau_display_vblank_fini(dev);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-11 16:24:15 +07:00
|
|
|
static void
|
|
|
|
nouveau_user_framebuffer_destroy(struct drm_framebuffer *drm_fb)
|
|
|
|
{
|
|
|
|
struct nouveau_framebuffer *fb = nouveau_framebuffer(drm_fb);
|
|
|
|
|
2010-02-09 12:49:12 +07:00
|
|
|
if (fb->nvbo)
|
2013-10-02 15:15:17 +07:00
|
|
|
drm_gem_object_unreference_unlocked(&fb->nvbo->gem);
|
2009-12-11 16:24:15 +07:00
|
|
|
|
|
|
|
drm_framebuffer_cleanup(drm_fb);
|
|
|
|
kfree(fb);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
nouveau_user_framebuffer_create_handle(struct drm_framebuffer *drm_fb,
|
|
|
|
struct drm_file *file_priv,
|
|
|
|
unsigned int *handle)
|
|
|
|
{
|
|
|
|
struct nouveau_framebuffer *fb = nouveau_framebuffer(drm_fb);
|
|
|
|
|
2013-10-02 15:15:17 +07:00
|
|
|
return drm_gem_handle_create(file_priv, &fb->nvbo->gem, handle);
|
2009-12-11 16:24:15 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct drm_framebuffer_funcs nouveau_framebuffer_funcs = {
|
|
|
|
.destroy = nouveau_user_framebuffer_destroy,
|
|
|
|
.create_handle = nouveau_user_framebuffer_create_handle,
|
|
|
|
};
|
|
|
|
|
2010-03-30 12:34:13 +07:00
|
|
|
int
|
2016-11-04 14:20:35 +07:00
|
|
|
nouveau_framebuffer_new(struct drm_device *dev,
|
|
|
|
const struct drm_mode_fb_cmd2 *mode_cmd,
|
|
|
|
struct nouveau_bo *nvbo,
|
|
|
|
struct nouveau_framebuffer **pfb)
|
2009-12-11 16:24:15 +07:00
|
|
|
{
|
2016-11-04 14:20:35 +07:00
|
|
|
struct nouveau_framebuffer *fb;
|
2009-12-11 16:24:15 +07:00
|
|
|
int ret;
|
|
|
|
|
2016-11-04 14:20:36 +07:00
|
|
|
if (!(fb = *pfb = kzalloc(sizeof(*fb), GFP_KERNEL)))
|
2016-11-04 14:20:35 +07:00
|
|
|
return -ENOMEM;
|
2011-02-09 08:57:45 +07:00
|
|
|
|
drm: Pass 'dev' to drm_helper_mode_fill_fb_struct()
Pass the drm_device to drm_helper_mode_fill_fb_struct() so that we can
populate fb->dev early. Will make it easier to use the fb before we
register it.
@@
identifier fb, mode_cmd;
@@
void drm_helper_mode_fill_fb_struct(
+ struct drm_device *dev,
struct drm_framebuffer *fb,
const struct drm_mode_fb_cmd2 *mode_cmd
);
@@
identifier fb, mode_cmd;
@@
void drm_helper_mode_fill_fb_struct(
+ struct drm_device *dev,
struct drm_framebuffer *fb,
const struct drm_mode_fb_cmd2 *mode_cmd
)
{ ... }
@@
function func;
identifier dev;
expression E1, E2;
@@
func(struct drm_device *dev, ...)
{
...
drm_helper_mode_fill_fb_struct(
+ dev,
E1, E2);
...
}
@@
expression E1, E2;
@@
drm_helper_mode_fill_fb_struct(
+ dev,
E1, E2);
v2: Rerun spatch due to code changes
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
Link: http://patchwork.freedesktop.org/patch/msgid/1481748539-18283-1-git-send-email-ville.syrjala@linux.intel.com
2016-12-15 03:48:59 +07:00
|
|
|
drm_helper_mode_fill_fb_struct(dev, &fb->base, mode_cmd);
|
2016-11-04 14:20:35 +07:00
|
|
|
fb->nvbo = nvbo;
|
2014-08-10 01:10:19 +07:00
|
|
|
|
2016-11-04 14:20:35 +07:00
|
|
|
ret = drm_framebuffer_init(dev, &fb->base, &nouveau_framebuffer_funcs);
|
2016-11-04 14:20:36 +07:00
|
|
|
if (ret)
|
|
|
|
kfree(fb);
|
2014-08-10 01:10:19 +07:00
|
|
|
return ret;
|
2009-12-11 16:24:15 +07:00
|
|
|
}
|
|
|
|
|
2016-11-04 14:20:36 +07:00
|
|
|
struct drm_framebuffer *
|
2009-12-11 16:24:15 +07:00
|
|
|
nouveau_user_framebuffer_create(struct drm_device *dev,
|
|
|
|
struct drm_file *file_priv,
|
2015-11-12 00:11:29 +07:00
|
|
|
const struct drm_mode_fb_cmd2 *mode_cmd)
|
2009-12-11 16:24:15 +07:00
|
|
|
{
|
2016-11-04 14:20:35 +07:00
|
|
|
struct nouveau_framebuffer *fb;
|
|
|
|
struct nouveau_bo *nvbo;
|
2009-12-11 16:24:15 +07:00
|
|
|
struct drm_gem_object *gem;
|
2016-11-04 14:20:35 +07:00
|
|
|
int ret;
|
2009-12-11 16:24:15 +07:00
|
|
|
|
2016-05-09 17:04:54 +07:00
|
|
|
gem = drm_gem_object_lookup(file_priv, mode_cmd->handles[0]);
|
2009-12-11 16:24:15 +07:00
|
|
|
if (!gem)
|
2010-08-08 19:36:38 +07:00
|
|
|
return ERR_PTR(-ENOENT);
|
2016-11-04 14:20:35 +07:00
|
|
|
nvbo = nouveau_gem_object(gem);
|
2009-12-11 16:24:15 +07:00
|
|
|
|
2016-11-04 14:20:35 +07:00
|
|
|
ret = nouveau_framebuffer_new(dev, mode_cmd, nvbo, &fb);
|
|
|
|
if (ret == 0)
|
|
|
|
return &fb->base;
|
2013-07-08 11:50:54 +07:00
|
|
|
|
2016-03-30 16:40:40 +07:00
|
|
|
drm_gem_object_unreference_unlocked(gem);
|
2013-07-08 11:50:54 +07:00
|
|
|
return ERR_PTR(ret);
|
2009-12-11 16:24:15 +07:00
|
|
|
}
|
|
|
|
|
2011-10-06 09:46:40 +07:00
|
|
|
static const struct drm_mode_config_funcs nouveau_mode_config_funcs = {
|
2009-12-11 16:24:15 +07:00
|
|
|
.fb_create = nouveau_user_framebuffer_create,
|
2010-05-07 13:42:51 +07:00
|
|
|
.output_poll_changed = nouveau_fbcon_output_poll_changed,
|
2009-12-11 16:24:15 +07:00
|
|
|
};
|
|
|
|
|
2011-10-06 10:29:05 +07:00
|
|
|
|
2012-02-06 16:58:17 +07:00
|
|
|
struct nouveau_drm_prop_enum_list {
|
2011-10-17 09:23:41 +07:00
|
|
|
u8 gen_mask;
|
2011-10-06 10:29:05 +07:00
|
|
|
int type;
|
|
|
|
char *name;
|
|
|
|
};
|
|
|
|
|
2012-02-06 16:58:17 +07:00
|
|
|
static struct nouveau_drm_prop_enum_list underscan[] = {
|
2011-11-11 20:49:06 +07:00
|
|
|
{ 6, UNDERSCAN_AUTO, "auto" },
|
|
|
|
{ 6, UNDERSCAN_OFF, "off" },
|
|
|
|
{ 6, UNDERSCAN_ON, "on" },
|
2011-10-17 09:23:41 +07:00
|
|
|
{}
|
2011-10-06 10:29:05 +07:00
|
|
|
};
|
|
|
|
|
2012-02-06 16:58:17 +07:00
|
|
|
static struct nouveau_drm_prop_enum_list dither_mode[] = {
|
2011-10-17 09:23:41 +07:00
|
|
|
{ 7, DITHERING_MODE_AUTO, "auto" },
|
|
|
|
{ 7, DITHERING_MODE_OFF, "off" },
|
|
|
|
{ 1, DITHERING_MODE_ON, "on" },
|
|
|
|
{ 6, DITHERING_MODE_STATIC2X2, "static 2x2" },
|
|
|
|
{ 6, DITHERING_MODE_DYNAMIC2X2, "dynamic 2x2" },
|
|
|
|
{ 4, DITHERING_MODE_TEMPORAL, "temporal" },
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
2012-02-06 16:58:17 +07:00
|
|
|
static struct nouveau_drm_prop_enum_list dither_depth[] = {
|
2011-10-17 09:23:41 +07:00
|
|
|
{ 6, DITHERING_DEPTH_AUTO, "auto" },
|
|
|
|
{ 6, DITHERING_DEPTH_6BPC, "6 bpc" },
|
|
|
|
{ 6, DITHERING_DEPTH_8BPC, "8 bpc" },
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
|
|
#define PROP_ENUM(p,gen,n,list) do { \
|
2012-02-06 16:58:17 +07:00
|
|
|
struct nouveau_drm_prop_enum_list *l = (list); \
|
2011-10-17 09:23:41 +07:00
|
|
|
int c = 0; \
|
|
|
|
while (l->gen_mask) { \
|
|
|
|
if (l->gen_mask & (1 << (gen))) \
|
|
|
|
c++; \
|
|
|
|
l++; \
|
|
|
|
} \
|
|
|
|
if (c) { \
|
|
|
|
p = drm_property_create(dev, DRM_MODE_PROP_ENUM, n, c); \
|
|
|
|
l = (list); \
|
|
|
|
c = 0; \
|
|
|
|
while (p && l->gen_mask) { \
|
|
|
|
if (l->gen_mask & (1 << (gen))) { \
|
|
|
|
drm_property_add_enum(p, c, l->type, l->name); \
|
|
|
|
c++; \
|
|
|
|
} \
|
|
|
|
l++; \
|
|
|
|
} \
|
|
|
|
} \
|
|
|
|
} while(0)
|
|
|
|
|
2016-11-10 00:17:44 +07:00
|
|
|
static void
|
2016-11-21 23:50:54 +07:00
|
|
|
nouveau_display_hpd_work(struct work_struct *work)
|
2016-11-10 00:17:44 +07:00
|
|
|
{
|
2016-11-21 23:50:54 +07:00
|
|
|
struct nouveau_drm *drm = container_of(work, typeof(*drm), hpd_work);
|
2016-11-10 00:17:44 +07:00
|
|
|
|
|
|
|
pm_runtime_get_sync(drm->dev->dev);
|
|
|
|
|
|
|
|
drm_helper_hpd_irq_event(drm->dev);
|
2017-05-15 16:04:31 +07:00
|
|
|
/* enable polling for external displays */
|
|
|
|
drm_kms_helper_poll_enable(drm->dev);
|
2016-11-10 00:17:44 +07:00
|
|
|
|
|
|
|
pm_runtime_mark_last_busy(drm->dev->dev);
|
|
|
|
pm_runtime_put_sync(drm->dev->dev);
|
|
|
|
}
|
|
|
|
|
2016-11-21 23:50:54 +07:00
|
|
|
#ifdef CONFIG_ACPI
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Hans de Goede: This define belongs in acpi/video.h, I've submitted a patch
|
|
|
|
* to the acpi subsys to move it there from drivers/acpi/acpi_video.c .
|
|
|
|
* This should be dropped once that is merged.
|
|
|
|
*/
|
|
|
|
#ifndef ACPI_VIDEO_NOTIFY_PROBE
|
|
|
|
#define ACPI_VIDEO_NOTIFY_PROBE 0x81
|
|
|
|
#endif
|
|
|
|
|
2016-11-10 00:17:44 +07:00
|
|
|
static int
|
|
|
|
nouveau_display_acpi_ntfy(struct notifier_block *nb, unsigned long val,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct nouveau_drm *drm = container_of(nb, typeof(*drm), acpi_nb);
|
|
|
|
struct acpi_bus_event *info = data;
|
|
|
|
|
|
|
|
if (!strcmp(info->device_class, ACPI_VIDEO_CLASS)) {
|
|
|
|
if (info->type == ACPI_VIDEO_NOTIFY_PROBE) {
|
|
|
|
/*
|
|
|
|
* This may be the only indication we receive of a
|
|
|
|
* connector hotplug on a runtime suspended GPU,
|
2016-11-21 23:50:54 +07:00
|
|
|
* schedule hpd_work to check.
|
2016-11-10 00:17:44 +07:00
|
|
|
*/
|
2016-11-21 23:50:54 +07:00
|
|
|
schedule_work(&drm->hpd_work);
|
2016-11-10 00:17:44 +07:00
|
|
|
|
|
|
|
/* acpi-video should not generate keypresses for this */
|
|
|
|
return NOTIFY_BAD;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2011-11-09 12:18:47 +07:00
|
|
|
int
|
|
|
|
nouveau_display_init(struct drm_device *dev)
|
|
|
|
{
|
2012-07-31 13:16:21 +07:00
|
|
|
struct nouveau_display *disp = nouveau_display(dev);
|
2015-08-20 11:54:18 +07:00
|
|
|
struct nouveau_drm *drm = nouveau_drm(dev);
|
2011-11-24 09:59:44 +07:00
|
|
|
struct drm_connector *connector;
|
2011-11-09 12:18:47 +07:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = disp->init(dev);
|
2011-11-24 09:59:44 +07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* enable hotplug interrupts */
|
|
|
|
list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
|
|
|
|
struct nouveau_connector *conn = nouveau_connector(connector);
|
2014-08-10 01:10:28 +07:00
|
|
|
nvif_notify_get(&conn->hpd);
|
2011-11-09 12:18:47 +07:00
|
|
|
}
|
|
|
|
|
2015-08-20 11:54:18 +07:00
|
|
|
/* enable flip completion events */
|
|
|
|
nvif_notify_get(&drm->flip);
|
2011-11-09 12:18:47 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2016-11-04 14:20:35 +07:00
|
|
|
nouveau_display_fini(struct drm_device *dev, bool suspend)
|
2011-11-09 12:18:47 +07:00
|
|
|
{
|
2012-07-31 13:16:21 +07:00
|
|
|
struct nouveau_display *disp = nouveau_display(dev);
|
2015-08-20 11:54:18 +07:00
|
|
|
struct nouveau_drm *drm = nouveau_drm(dev);
|
2011-11-24 09:59:44 +07:00
|
|
|
struct drm_connector *connector;
|
2016-11-16 04:58:19 +07:00
|
|
|
struct drm_crtc *crtc;
|
drm/nouveau: Dis/Enable vblank irqs during suspend/resume.
Vblank irqs don't get disabled during suspend or driver
unload, which causes irq delivery after "suspend" or
driver unload, at least until the gpu is powered off.
This could race with drm_vblank_cleanup() in the case
of nouveau and cause a use-after-free bug if the driver
is unloaded.
More annoyingly during everyday use, at least on nv50
display engine (likely also others), vblank irqs are
off after a resume from suspend, but the drm doesn't
know this, so all vblank related functionality is dead
after a resume. E.g., all windowed OpenGL clients will
hang at swapbuffers time, as well as many fullscreen
clients in many cases. This makes suspend/resume useless
if one wants to use any OpenGL apps after the resume.
In Linux 3.16, drm_vblank_on() was added, complementing
the older drm_vblank_off() to solve these problems
elegantly, so use those calls in nouveaus suspend/resume
code.
For kernels 3.8 - 3.15, we need to cherry-pick the
drm_vblank_on() patch to support this patch.
Signed-off-by: Mario Kleiner <mario.kleiner.de@gmail.com>
Cc: <stable@vger.kernel.org> #v3.16
Cc: <stable@vger.kernel.org> #v3.8+: f275228: drm: Add drm_vblank_on()
Signed-off-by: Ben Skeggs <bskeggs@redhat.com>
2014-07-29 07:36:44 +07:00
|
|
|
|
2017-03-21 23:41:49 +07:00
|
|
|
if (!suspend) {
|
|
|
|
if (drm_drv_uses_atomic_modeset(dev))
|
|
|
|
drm_atomic_helper_shutdown(dev);
|
|
|
|
else
|
|
|
|
drm_crtc_force_disable_all(dev);
|
|
|
|
}
|
2016-11-04 14:20:35 +07:00
|
|
|
|
drm/nouveau: Dis/Enable vblank irqs during suspend/resume.
Vblank irqs don't get disabled during suspend or driver
unload, which causes irq delivery after "suspend" or
driver unload, at least until the gpu is powered off.
This could race with drm_vblank_cleanup() in the case
of nouveau and cause a use-after-free bug if the driver
is unloaded.
More annoyingly during everyday use, at least on nv50
display engine (likely also others), vblank irqs are
off after a resume from suspend, but the drm doesn't
know this, so all vblank related functionality is dead
after a resume. E.g., all windowed OpenGL clients will
hang at swapbuffers time, as well as many fullscreen
clients in many cases. This makes suspend/resume useless
if one wants to use any OpenGL apps after the resume.
In Linux 3.16, drm_vblank_on() was added, complementing
the older drm_vblank_off() to solve these problems
elegantly, so use those calls in nouveaus suspend/resume
code.
For kernels 3.8 - 3.15, we need to cherry-pick the
drm_vblank_on() patch to support this patch.
Signed-off-by: Mario Kleiner <mario.kleiner.de@gmail.com>
Cc: <stable@vger.kernel.org> #v3.16
Cc: <stable@vger.kernel.org> #v3.8+: f275228: drm: Add drm_vblank_on()
Signed-off-by: Ben Skeggs <bskeggs@redhat.com>
2014-07-29 07:36:44 +07:00
|
|
|
/* Make sure that drm and hw vblank irqs get properly disabled. */
|
2016-11-16 04:58:19 +07:00
|
|
|
drm_for_each_crtc(crtc, dev)
|
|
|
|
drm_crtc_vblank_off(crtc);
|
2011-11-24 09:59:44 +07:00
|
|
|
|
2015-08-20 11:54:18 +07:00
|
|
|
/* disable flip completion events */
|
|
|
|
nvif_notify_put(&drm->flip);
|
|
|
|
|
2011-11-24 09:59:44 +07:00
|
|
|
/* disable hotplug interrupts */
|
|
|
|
list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
|
|
|
|
struct nouveau_connector *conn = nouveau_connector(connector);
|
2014-08-10 01:10:28 +07:00
|
|
|
nvif_notify_put(&conn->hpd);
|
2011-11-24 09:59:44 +07:00
|
|
|
}
|
2011-11-09 12:18:47 +07:00
|
|
|
|
|
|
|
drm_kms_helper_poll_disable(dev);
|
|
|
|
disp->fini(dev);
|
|
|
|
}
|
|
|
|
|
2014-08-10 01:10:21 +07:00
|
|
|
static void
|
|
|
|
nouveau_display_create_properties(struct drm_device *dev)
|
2011-10-06 09:46:40 +07:00
|
|
|
{
|
2014-08-10 01:10:21 +07:00
|
|
|
struct nouveau_display *disp = nouveau_display(dev);
|
|
|
|
int gen;
|
2011-10-17 09:23:41 +07:00
|
|
|
|
2014-08-10 01:10:27 +07:00
|
|
|
if (disp->disp.oclass < NV50_DISP)
|
2011-10-17 09:23:41 +07:00
|
|
|
gen = 0;
|
|
|
|
else
|
2014-08-10 01:10:27 +07:00
|
|
|
if (disp->disp.oclass < GF110_DISP)
|
2011-10-17 09:23:41 +07:00
|
|
|
gen = 1;
|
|
|
|
else
|
|
|
|
gen = 2;
|
|
|
|
|
|
|
|
PROP_ENUM(disp->dithering_mode, gen, "dithering mode", dither_mode);
|
|
|
|
PROP_ENUM(disp->dithering_depth, gen, "dithering depth", dither_depth);
|
|
|
|
PROP_ENUM(disp->underscan_property, gen, "underscan", underscan);
|
2011-10-06 10:29:05 +07:00
|
|
|
|
|
|
|
disp->underscan_hborder_property =
|
2012-02-06 16:58:18 +07:00
|
|
|
drm_property_create_range(dev, 0, "underscan hborder", 0, 128);
|
2011-10-06 10:29:05 +07:00
|
|
|
|
|
|
|
disp->underscan_vborder_property =
|
2012-02-06 16:58:18 +07:00
|
|
|
drm_property_create_range(dev, 0, "underscan vborder", 0, 128);
|
2011-10-06 10:29:05 +07:00
|
|
|
|
2014-08-10 01:10:21 +07:00
|
|
|
if (gen < 1)
|
|
|
|
return;
|
2012-01-22 05:13:26 +07:00
|
|
|
|
2014-08-10 01:10:21 +07:00
|
|
|
/* -90..+90 */
|
|
|
|
disp->vibrant_hue_property =
|
|
|
|
drm_property_create_range(dev, 0, "vibrant hue", 0, 180);
|
|
|
|
|
|
|
|
/* -100..+100 */
|
|
|
|
disp->color_vibrance_property =
|
|
|
|
drm_property_create_range(dev, 0, "color vibrance", 0, 200);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
nouveau_display_create(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct nouveau_drm *drm = nouveau_drm(dev);
|
2016-05-18 10:57:42 +07:00
|
|
|
struct nvkm_device *device = nvxx_device(&drm->client.device);
|
2014-08-10 01:10:21 +07:00
|
|
|
struct nouveau_display *disp;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
disp = drm->display = kzalloc(sizeof(*disp), GFP_KERNEL);
|
|
|
|
if (!disp)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
drm_mode_config_init(dev);
|
|
|
|
drm_mode_create_scaling_mode_property(dev);
|
|
|
|
drm_mode_create_dvi_i_properties(dev);
|
2012-01-22 05:13:26 +07:00
|
|
|
|
2012-05-17 18:27:23 +07:00
|
|
|
dev->mode_config.funcs = &nouveau_mode_config_funcs;
|
2015-08-20 11:54:23 +07:00
|
|
|
dev->mode_config.fb_base = device->func->resource_addr(device, 1);
|
2011-10-06 09:46:40 +07:00
|
|
|
|
|
|
|
dev->mode_config.min_width = 0;
|
|
|
|
dev->mode_config.min_height = 0;
|
2016-05-18 10:57:42 +07:00
|
|
|
if (drm->client.device.info.family < NV_DEVICE_INFO_V0_CELSIUS) {
|
2011-10-06 09:46:40 +07:00
|
|
|
dev->mode_config.max_width = 2048;
|
|
|
|
dev->mode_config.max_height = 2048;
|
|
|
|
} else
|
2016-05-18 10:57:42 +07:00
|
|
|
if (drm->client.device.info.family < NV_DEVICE_INFO_V0_TESLA) {
|
2011-10-06 09:46:40 +07:00
|
|
|
dev->mode_config.max_width = 4096;
|
|
|
|
dev->mode_config.max_height = 4096;
|
2015-09-18 09:31:20 +07:00
|
|
|
} else
|
2016-05-18 10:57:42 +07:00
|
|
|
if (drm->client.device.info.family < NV_DEVICE_INFO_V0_FERMI) {
|
2011-10-06 09:46:40 +07:00
|
|
|
dev->mode_config.max_width = 8192;
|
|
|
|
dev->mode_config.max_height = 8192;
|
2015-09-18 09:31:20 +07:00
|
|
|
} else {
|
|
|
|
dev->mode_config.max_width = 16384;
|
|
|
|
dev->mode_config.max_height = 16384;
|
2011-10-06 09:46:40 +07:00
|
|
|
}
|
|
|
|
|
2012-02-20 21:39:11 +07:00
|
|
|
dev->mode_config.preferred_depth = 24;
|
|
|
|
dev->mode_config.prefer_shadow = 1;
|
|
|
|
|
2016-05-18 10:57:42 +07:00
|
|
|
if (drm->client.device.info.chipset < 0x11)
|
2013-11-11 10:59:40 +07:00
|
|
|
dev->mode_config.async_page_flip = false;
|
|
|
|
else
|
|
|
|
dev->mode_config.async_page_flip = true;
|
|
|
|
|
2011-11-09 12:18:47 +07:00
|
|
|
drm_kms_helper_poll_init(dev);
|
|
|
|
drm_kms_helper_poll_disable(dev);
|
|
|
|
|
2014-08-10 01:10:31 +07:00
|
|
|
if (nouveau_modeset != 2 && drm->vbios.dcb.entries) {
|
2014-01-22 09:58:12 +07:00
|
|
|
static const u16 oclass[] = {
|
2016-11-16 12:03:07 +07:00
|
|
|
GP102_DISP,
|
2016-07-09 07:41:01 +07:00
|
|
|
GP100_DISP,
|
2016-02-11 05:35:32 +07:00
|
|
|
GM200_DISP,
|
2014-08-10 01:10:27 +07:00
|
|
|
GM107_DISP,
|
|
|
|
GK110_DISP,
|
|
|
|
GK104_DISP,
|
|
|
|
GF110_DISP,
|
|
|
|
GT214_DISP,
|
|
|
|
GT206_DISP,
|
|
|
|
GT200_DISP,
|
|
|
|
G82_DISP,
|
|
|
|
NV50_DISP,
|
|
|
|
NV04_DISP,
|
2014-01-22 09:58:12 +07:00
|
|
|
};
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0, ret = -ENODEV; ret && i < ARRAY_SIZE(oclass); i++) {
|
2016-05-18 10:57:42 +07:00
|
|
|
ret = nvif_object_init(&drm->client.device.object, 0,
|
2015-09-04 11:40:32 +07:00
|
|
|
oclass[i], NULL, 0, &disp->disp);
|
2014-01-22 09:58:12 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ret == 0) {
|
2014-08-10 01:10:21 +07:00
|
|
|
nouveau_display_create_properties(dev);
|
2014-08-10 01:10:27 +07:00
|
|
|
if (disp->disp.oclass < NV50_DISP)
|
2014-01-22 09:58:12 +07:00
|
|
|
ret = nv04_display_create(dev);
|
|
|
|
else
|
|
|
|
ret = nv50_display_create(dev);
|
|
|
|
}
|
2013-09-10 10:20:34 +07:00
|
|
|
} else {
|
|
|
|
ret = 0;
|
|
|
|
}
|
2012-10-31 09:11:15 +07:00
|
|
|
|
2013-09-10 10:20:34 +07:00
|
|
|
if (ret)
|
|
|
|
goto disp_create_err;
|
2012-10-31 09:11:15 +07:00
|
|
|
|
2016-11-04 14:20:35 +07:00
|
|
|
drm_mode_config_reset(dev);
|
|
|
|
|
2013-09-10 10:20:34 +07:00
|
|
|
if (dev->mode_config.num_crtc) {
|
2013-10-03 04:02:29 +07:00
|
|
|
ret = nouveau_display_vblank_init(dev);
|
2013-09-10 10:20:34 +07:00
|
|
|
if (ret)
|
|
|
|
goto vblank_err;
|
2011-11-09 12:18:47 +07:00
|
|
|
}
|
|
|
|
|
2013-09-10 10:20:34 +07:00
|
|
|
nouveau_backlight_init(dev);
|
2016-11-21 23:50:54 +07:00
|
|
|
INIT_WORK(&drm->hpd_work, nouveau_display_hpd_work);
|
2016-11-10 00:17:44 +07:00
|
|
|
#ifdef CONFIG_ACPI
|
|
|
|
drm->acpi_nb.notifier_call = nouveau_display_acpi_ntfy;
|
|
|
|
register_acpi_notifier(&drm->acpi_nb);
|
|
|
|
#endif
|
|
|
|
|
2012-04-15 19:36:08 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
vblank_err:
|
2012-07-31 13:16:21 +07:00
|
|
|
disp->dtor(dev);
|
2012-04-15 19:36:08 +07:00
|
|
|
disp_create_err:
|
|
|
|
drm_kms_helper_poll_fini(dev);
|
|
|
|
drm_mode_config_cleanup(dev);
|
2011-11-09 08:36:33 +07:00
|
|
|
return ret;
|
2011-10-06 09:46:40 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nouveau_display_destroy(struct drm_device *dev)
|
|
|
|
{
|
2012-07-31 13:16:21 +07:00
|
|
|
struct nouveau_display *disp = nouveau_display(dev);
|
2011-10-06 09:46:40 +07:00
|
|
|
|
2016-11-10 00:17:44 +07:00
|
|
|
#ifdef CONFIG_ACPI
|
|
|
|
unregister_acpi_notifier(&nouveau_drm(dev)->acpi_nb);
|
|
|
|
#endif
|
2012-07-31 13:16:21 +07:00
|
|
|
nouveau_backlight_exit(dev);
|
2013-10-03 04:02:29 +07:00
|
|
|
nouveau_display_vblank_fini(dev);
|
2011-11-09 12:18:47 +07:00
|
|
|
|
2012-10-30 07:59:12 +07:00
|
|
|
drm_kms_helper_poll_fini(dev);
|
|
|
|
drm_mode_config_cleanup(dev);
|
|
|
|
|
2012-10-31 09:11:15 +07:00
|
|
|
if (disp->dtor)
|
|
|
|
disp->dtor(dev);
|
2011-11-09 12:18:47 +07:00
|
|
|
|
2014-08-10 01:10:22 +07:00
|
|
|
nvif_object_fini(&disp->disp);
|
2014-01-22 09:58:12 +07:00
|
|
|
|
2012-07-31 13:16:21 +07:00
|
|
|
nouveau_drm(dev)->display = NULL;
|
|
|
|
kfree(disp);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2014-10-02 10:22:27 +07:00
|
|
|
nouveau_display_suspend(struct drm_device *dev, bool runtime)
|
2012-07-31 13:16:21 +07:00
|
|
|
{
|
2016-11-04 14:20:36 +07:00
|
|
|
struct nouveau_display *disp = nouveau_display(dev);
|
2012-07-31 13:16:21 +07:00
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
2016-12-22 15:50:42 +07:00
|
|
|
if (drm_drv_uses_atomic_modeset(dev)) {
|
2016-11-04 14:20:36 +07:00
|
|
|
if (!runtime) {
|
2017-02-21 20:51:40 +07:00
|
|
|
disp->suspend = drm_atomic_helper_suspend(dev);
|
2016-11-04 14:20:36 +07:00
|
|
|
if (IS_ERR(disp->suspend)) {
|
|
|
|
int ret = PTR_ERR(disp->suspend);
|
|
|
|
disp->suspend = NULL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
nouveau_display_fini(dev, true);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-11-04 14:20:35 +07:00
|
|
|
nouveau_display_fini(dev, true);
|
2012-07-31 13:16:21 +07:00
|
|
|
|
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
struct nouveau_framebuffer *nouveau_fb;
|
|
|
|
|
2014-04-02 05:22:40 +07:00
|
|
|
nouveau_fb = nouveau_framebuffer(crtc->primary->fb);
|
2012-07-31 13:16:21 +07:00
|
|
|
if (!nouveau_fb || !nouveau_fb->nvbo)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
nouveau_bo_unpin(nouveau_fb->nvbo);
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
|
2014-11-10 12:52:02 +07:00
|
|
|
if (nv_crtc->cursor.nvbo) {
|
2015-01-13 15:18:49 +07:00
|
|
|
if (nv_crtc->cursor.set_offset)
|
|
|
|
nouveau_bo_unmap(nv_crtc->cursor.nvbo);
|
2014-11-10 12:52:02 +07:00
|
|
|
nouveau_bo_unpin(nv_crtc->cursor.nvbo);
|
|
|
|
}
|
2012-07-31 13:16:21 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2014-10-02 10:22:27 +07:00
|
|
|
nouveau_display_resume(struct drm_device *dev, bool runtime)
|
2012-07-31 13:16:21 +07:00
|
|
|
{
|
2016-11-04 14:20:36 +07:00
|
|
|
struct nouveau_display *disp = nouveau_display(dev);
|
2012-07-31 13:16:21 +07:00
|
|
|
struct nouveau_drm *drm = nouveau_drm(dev);
|
|
|
|
struct drm_crtc *crtc;
|
2016-11-16 04:58:19 +07:00
|
|
|
int ret;
|
2012-07-31 13:16:21 +07:00
|
|
|
|
2016-12-22 15:50:42 +07:00
|
|
|
if (drm_drv_uses_atomic_modeset(dev)) {
|
2016-11-04 14:20:36 +07:00
|
|
|
nouveau_display_init(dev);
|
|
|
|
if (disp->suspend) {
|
|
|
|
drm_atomic_helper_resume(dev, disp->suspend);
|
|
|
|
disp->suspend = NULL;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-10-02 10:22:27 +07:00
|
|
|
/* re-pin fb/cursors */
|
2012-07-31 13:16:21 +07:00
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
struct nouveau_framebuffer *nouveau_fb;
|
|
|
|
|
2014-04-02 05:22:40 +07:00
|
|
|
nouveau_fb = nouveau_framebuffer(crtc->primary->fb);
|
2012-07-31 13:16:21 +07:00
|
|
|
if (!nouveau_fb || !nouveau_fb->nvbo)
|
|
|
|
continue;
|
|
|
|
|
2014-11-10 09:35:06 +07:00
|
|
|
ret = nouveau_bo_pin(nouveau_fb->nvbo, TTM_PL_FLAG_VRAM, true);
|
2014-08-12 20:35:35 +07:00
|
|
|
if (ret)
|
|
|
|
NV_ERROR(drm, "Could not pin framebuffer\n");
|
2012-07-31 13:16:21 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
|
2014-11-10 12:52:02 +07:00
|
|
|
if (!nv_crtc->cursor.nvbo)
|
|
|
|
continue;
|
2012-07-31 13:16:21 +07:00
|
|
|
|
2014-11-10 09:35:06 +07:00
|
|
|
ret = nouveau_bo_pin(nv_crtc->cursor.nvbo, TTM_PL_FLAG_VRAM, true);
|
2015-01-13 15:18:49 +07:00
|
|
|
if (!ret && nv_crtc->cursor.set_offset)
|
2012-07-31 13:16:21 +07:00
|
|
|
ret = nouveau_bo_map(nv_crtc->cursor.nvbo);
|
|
|
|
if (ret)
|
|
|
|
NV_ERROR(drm, "Could not pin/map cursor.\n");
|
|
|
|
}
|
drm/nouveau: Dis/Enable vblank irqs during suspend/resume.
Vblank irqs don't get disabled during suspend or driver
unload, which causes irq delivery after "suspend" or
driver unload, at least until the gpu is powered off.
This could race with drm_vblank_cleanup() in the case
of nouveau and cause a use-after-free bug if the driver
is unloaded.
More annoyingly during everyday use, at least on nv50
display engine (likely also others), vblank irqs are
off after a resume from suspend, but the drm doesn't
know this, so all vblank related functionality is dead
after a resume. E.g., all windowed OpenGL clients will
hang at swapbuffers time, as well as many fullscreen
clients in many cases. This makes suspend/resume useless
if one wants to use any OpenGL apps after the resume.
In Linux 3.16, drm_vblank_on() was added, complementing
the older drm_vblank_off() to solve these problems
elegantly, so use those calls in nouveaus suspend/resume
code.
For kernels 3.8 - 3.15, we need to cherry-pick the
drm_vblank_on() patch to support this patch.
Signed-off-by: Mario Kleiner <mario.kleiner.de@gmail.com>
Cc: <stable@vger.kernel.org> #v3.16
Cc: <stable@vger.kernel.org> #v3.8+: f275228: drm: Add drm_vblank_on()
Signed-off-by: Ben Skeggs <bskeggs@redhat.com>
2014-07-29 07:36:44 +07:00
|
|
|
|
2012-07-31 13:16:21 +07:00
|
|
|
nouveau_display_init(dev);
|
|
|
|
|
|
|
|
/* Force CLUT to get re-loaded during modeset */
|
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
|
|
|
|
|
|
|
|
nv_crtc->lut.depth = 0;
|
|
|
|
}
|
|
|
|
|
2014-10-02 10:22:27 +07:00
|
|
|
/* This should ensure we don't hit a locking problem when someone
|
|
|
|
* wakes us up via a connector. We should never go into suspend
|
|
|
|
* while the display is on anyways.
|
|
|
|
*/
|
|
|
|
if (runtime)
|
|
|
|
return;
|
|
|
|
|
2012-07-31 13:16:21 +07:00
|
|
|
drm_helper_resume_force_mode(dev);
|
|
|
|
|
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
|
|
|
|
|
2014-11-10 12:52:02 +07:00
|
|
|
if (!nv_crtc->cursor.nvbo)
|
2014-11-03 11:33:01 +07:00
|
|
|
continue;
|
2015-01-13 15:18:49 +07:00
|
|
|
|
|
|
|
if (nv_crtc->cursor.set_offset)
|
|
|
|
nv_crtc->cursor.set_offset(nv_crtc, nv_crtc->cursor.nvbo->bo.offset);
|
2012-07-31 13:16:21 +07:00
|
|
|
nv_crtc->cursor.set_pos(nv_crtc, nv_crtc->cursor_saved_x,
|
|
|
|
nv_crtc->cursor_saved_y);
|
|
|
|
}
|
2011-10-06 09:46:40 +07:00
|
|
|
}
|
|
|
|
|
2010-10-21 04:35:40 +07:00
|
|
|
static int
|
|
|
|
nouveau_page_flip_emit(struct nouveau_channel *chan,
|
|
|
|
struct nouveau_bo *old_bo,
|
|
|
|
struct nouveau_bo *new_bo,
|
|
|
|
struct nouveau_page_flip_state *s,
|
|
|
|
struct nouveau_fence **pfence)
|
|
|
|
{
|
2012-07-22 08:55:54 +07:00
|
|
|
struct nouveau_fence_chan *fctx = chan->fence;
|
2012-07-31 13:16:21 +07:00
|
|
|
struct nouveau_drm *drm = chan->drm;
|
|
|
|
struct drm_device *dev = drm->dev;
|
2010-10-21 04:35:40 +07:00
|
|
|
unsigned long flags;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Queue it to the pending list */
|
|
|
|
spin_lock_irqsave(&dev->event_lock, flags);
|
2012-07-22 08:55:54 +07:00
|
|
|
list_add_tail(&s->head, &fctx->flip);
|
2010-10-21 04:35:40 +07:00
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
|
|
|
|
|
|
|
/* Synchronize with the old framebuffer */
|
2014-09-16 16:15:07 +07:00
|
|
|
ret = nouveau_fence_sync(old_bo, chan, false, false);
|
2010-10-21 04:35:40 +07:00
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
/* Emit the pageflip */
|
2013-11-13 07:49:46 +07:00
|
|
|
ret = RING_SPACE(chan, 2);
|
2010-10-21 04:35:40 +07:00
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
|
2016-11-04 14:20:36 +07:00
|
|
|
BEGIN_NV04(chan, NvSubSw, NV_SW_PAGE_FLIP, 1);
|
2013-11-13 07:49:46 +07:00
|
|
|
OUT_RING (chan, 0x00000000);
|
2011-02-08 12:16:23 +07:00
|
|
|
FIRE_RING (chan);
|
2010-10-21 04:35:40 +07:00
|
|
|
|
2013-02-14 10:43:21 +07:00
|
|
|
ret = nouveau_fence_new(chan, false, pfence);
|
2010-10-21 04:35:40 +07:00
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
fail:
|
|
|
|
spin_lock_irqsave(&dev->event_lock, flags);
|
|
|
|
list_del(&s->head);
|
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
nouveau_crtc_page_flip(struct drm_crtc *crtc, struct drm_framebuffer *fb,
|
2017-03-23 04:50:50 +07:00
|
|
|
struct drm_pending_vblank_event *event, u32 flags,
|
|
|
|
struct drm_modeset_acquire_ctx *ctx)
|
2010-10-21 04:35:40 +07:00
|
|
|
{
|
2013-11-11 10:59:40 +07:00
|
|
|
const int swap_interval = (flags & DRM_MODE_PAGE_FLIP_ASYNC) ? 0 : 1;
|
2010-10-21 04:35:40 +07:00
|
|
|
struct drm_device *dev = crtc->dev;
|
2012-07-31 13:16:21 +07:00
|
|
|
struct nouveau_drm *drm = nouveau_drm(dev);
|
2014-04-02 05:22:40 +07:00
|
|
|
struct nouveau_bo *old_bo = nouveau_framebuffer(crtc->primary->fb)->nvbo;
|
2010-10-21 04:35:40 +07:00
|
|
|
struct nouveau_bo *new_bo = nouveau_framebuffer(fb)->nvbo;
|
|
|
|
struct nouveau_page_flip_state *s;
|
2014-08-10 01:10:22 +07:00
|
|
|
struct nouveau_channel *chan;
|
|
|
|
struct nouveau_cli *cli;
|
2010-10-21 04:35:40 +07:00
|
|
|
struct nouveau_fence *fence;
|
2016-11-04 14:20:36 +07:00
|
|
|
struct nv04_display *dispnv04 = nv04_display(dev);
|
|
|
|
int head = nouveau_crtc(crtc)->index;
|
2010-10-21 04:35:40 +07:00
|
|
|
int ret;
|
|
|
|
|
2014-08-10 01:10:22 +07:00
|
|
|
chan = drm->channel;
|
|
|
|
if (!chan)
|
2010-10-21 04:35:40 +07:00
|
|
|
return -ENODEV;
|
2015-08-20 11:54:15 +07:00
|
|
|
cli = (void *)chan->user.client;
|
2010-10-21 04:35:40 +07:00
|
|
|
|
|
|
|
s = kzalloc(sizeof(*s), GFP_KERNEL);
|
|
|
|
if (!s)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2014-01-14 22:48:58 +07:00
|
|
|
if (new_bo != old_bo) {
|
2014-11-10 09:35:06 +07:00
|
|
|
ret = nouveau_bo_pin(new_bo, TTM_PL_FLAG_VRAM, true);
|
2014-01-14 22:48:58 +07:00
|
|
|
if (ret)
|
|
|
|
goto fail_free;
|
|
|
|
}
|
|
|
|
|
2014-08-10 01:10:22 +07:00
|
|
|
mutex_lock(&cli->mutex);
|
2016-04-06 16:12:03 +07:00
|
|
|
ret = ttm_bo_reserve(&new_bo->bo, true, false, NULL);
|
2013-11-13 07:17:17 +07:00
|
|
|
if (ret)
|
2014-01-29 17:05:09 +07:00
|
|
|
goto fail_unpin;
|
2013-06-27 18:48:18 +07:00
|
|
|
|
2013-11-13 07:17:17 +07:00
|
|
|
/* synchronise rendering channel with the kernel's channel */
|
2014-09-16 16:15:07 +07:00
|
|
|
ret = nouveau_fence_sync(new_bo, chan, false, true);
|
2014-01-21 19:02:14 +07:00
|
|
|
if (ret) {
|
|
|
|
ttm_bo_unreserve(&new_bo->bo);
|
2013-07-08 11:15:51 +07:00
|
|
|
goto fail_unpin;
|
2014-01-21 19:02:14 +07:00
|
|
|
}
|
2013-06-27 18:48:18 +07:00
|
|
|
|
2014-01-21 19:02:14 +07:00
|
|
|
if (new_bo != old_bo) {
|
|
|
|
ttm_bo_unreserve(&new_bo->bo);
|
|
|
|
|
2016-04-06 16:12:03 +07:00
|
|
|
ret = ttm_bo_reserve(&old_bo->bo, true, false, NULL);
|
2014-01-21 19:02:14 +07:00
|
|
|
if (ret)
|
|
|
|
goto fail_unpin;
|
|
|
|
}
|
2013-06-27 18:48:18 +07:00
|
|
|
|
|
|
|
/* Initialize a page flip struct */
|
|
|
|
*s = (struct nouveau_page_flip_state)
|
2016-12-15 04:32:20 +07:00
|
|
|
{ { }, event, crtc, fb->format->cpp[0] * 8, fb->pitches[0],
|
2013-06-27 18:48:18 +07:00
|
|
|
new_bo->bo.offset };
|
|
|
|
|
2014-06-11 14:51:23 +07:00
|
|
|
/* Keep vblanks on during flip, for the target crtc of this flip */
|
2016-06-07 21:07:53 +07:00
|
|
|
drm_crtc_vblank_get(crtc);
|
2014-06-11 14:51:23 +07:00
|
|
|
|
2010-10-21 04:35:40 +07:00
|
|
|
/* Emit a page flip */
|
2016-11-04 14:20:36 +07:00
|
|
|
if (swap_interval) {
|
|
|
|
ret = RING_SPACE(chan, 8);
|
2013-07-08 11:15:51 +07:00
|
|
|
if (ret)
|
2011-02-07 11:27:04 +07:00
|
|
|
goto fail_unreserve;
|
2013-11-11 10:59:40 +07:00
|
|
|
|
2016-11-04 14:20:36 +07:00
|
|
|
BEGIN_NV04(chan, NvSubImageBlit, 0x012c, 1);
|
|
|
|
OUT_RING (chan, 0);
|
|
|
|
BEGIN_NV04(chan, NvSubImageBlit, 0x0134, 1);
|
|
|
|
OUT_RING (chan, head);
|
|
|
|
BEGIN_NV04(chan, NvSubImageBlit, 0x0100, 1);
|
|
|
|
OUT_RING (chan, 0);
|
|
|
|
BEGIN_NV04(chan, NvSubImageBlit, 0x0130, 1);
|
|
|
|
OUT_RING (chan, 0);
|
2011-02-07 11:27:04 +07:00
|
|
|
}
|
|
|
|
|
2016-11-04 14:20:36 +07:00
|
|
|
nouveau_bo_ref(new_bo, &dispnv04->image[head]);
|
|
|
|
|
2010-10-21 04:35:40 +07:00
|
|
|
ret = nouveau_page_flip_emit(chan, old_bo, new_bo, s, &fence);
|
|
|
|
if (ret)
|
|
|
|
goto fail_unreserve;
|
2014-08-10 01:10:22 +07:00
|
|
|
mutex_unlock(&cli->mutex);
|
2010-10-21 04:35:40 +07:00
|
|
|
|
|
|
|
/* Update the crtc struct and cleanup */
|
2014-04-02 05:22:40 +07:00
|
|
|
crtc->primary->fb = fb;
|
2010-10-21 04:35:40 +07:00
|
|
|
|
2014-04-09 21:19:30 +07:00
|
|
|
nouveau_bo_fence(old_bo, fence, false);
|
2013-11-13 07:00:32 +07:00
|
|
|
ttm_bo_unreserve(&old_bo->bo);
|
2013-07-08 11:15:51 +07:00
|
|
|
if (old_bo != new_bo)
|
2013-06-27 18:48:18 +07:00
|
|
|
nouveau_bo_unpin(old_bo);
|
2010-10-21 04:35:40 +07:00
|
|
|
nouveau_fence_unref(&fence);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail_unreserve:
|
2016-06-07 21:07:53 +07:00
|
|
|
drm_crtc_vblank_put(crtc);
|
2013-11-13 07:00:32 +07:00
|
|
|
ttm_bo_unreserve(&old_bo->bo);
|
2013-07-08 11:15:51 +07:00
|
|
|
fail_unpin:
|
2014-08-10 01:10:22 +07:00
|
|
|
mutex_unlock(&cli->mutex);
|
2013-07-08 11:15:51 +07:00
|
|
|
if (old_bo != new_bo)
|
2013-06-27 18:48:18 +07:00
|
|
|
nouveau_bo_unpin(new_bo);
|
2010-10-21 04:35:40 +07:00
|
|
|
fail_free:
|
|
|
|
kfree(s);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
nouveau_finish_page_flip(struct nouveau_channel *chan,
|
|
|
|
struct nouveau_page_flip_state *ps)
|
|
|
|
{
|
2012-07-22 08:55:54 +07:00
|
|
|
struct nouveau_fence_chan *fctx = chan->fence;
|
2012-07-31 13:16:21 +07:00
|
|
|
struct nouveau_drm *drm = chan->drm;
|
|
|
|
struct drm_device *dev = drm->dev;
|
2010-10-21 04:35:40 +07:00
|
|
|
struct nouveau_page_flip_state *s;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&dev->event_lock, flags);
|
|
|
|
|
2012-07-22 08:55:54 +07:00
|
|
|
if (list_empty(&fctx->flip)) {
|
2012-07-31 13:16:21 +07:00
|
|
|
NV_ERROR(drm, "unexpected pageflip\n");
|
2010-10-21 04:35:40 +07:00
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-07-22 08:55:54 +07:00
|
|
|
s = list_first_entry(&fctx->flip, struct nouveau_page_flip_state, head);
|
2014-05-13 05:42:08 +07:00
|
|
|
if (s->event) {
|
2016-11-04 14:20:36 +07:00
|
|
|
drm_crtc_arm_vblank_event(s->crtc, s->event);
|
|
|
|
} else {
|
2015-11-10 23:37:31 +07:00
|
|
|
/* Give up ownership of vblank for page-flipped crtc */
|
2016-06-07 21:07:53 +07:00
|
|
|
drm_crtc_vblank_put(s->crtc);
|
2014-05-13 05:42:08 +07:00
|
|
|
}
|
2014-06-11 14:51:23 +07:00
|
|
|
|
2010-10-21 04:35:40 +07:00
|
|
|
list_del(&s->head);
|
2011-02-07 11:27:04 +07:00
|
|
|
if (ps)
|
|
|
|
*ps = *s;
|
2010-10-21 04:35:40 +07:00
|
|
|
kfree(s);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
|
|
|
return 0;
|
|
|
|
}
|
2011-09-30 05:55:50 +07:00
|
|
|
|
2012-07-22 08:55:54 +07:00
|
|
|
int
|
2015-08-20 11:54:18 +07:00
|
|
|
nouveau_flip_complete(struct nvif_notify *notify)
|
2012-07-22 08:55:54 +07:00
|
|
|
{
|
2015-08-20 11:54:18 +07:00
|
|
|
struct nouveau_drm *drm = container_of(notify, typeof(*drm), flip);
|
|
|
|
struct nouveau_channel *chan = drm->channel;
|
2012-07-22 08:55:54 +07:00
|
|
|
struct nouveau_page_flip_state state;
|
|
|
|
|
|
|
|
if (!nouveau_finish_page_flip(chan, &state)) {
|
2016-11-04 14:20:36 +07:00
|
|
|
nv_set_crtc_base(drm->dev, drm_crtc_index(state.crtc),
|
|
|
|
state.offset + state.crtc->y *
|
|
|
|
state.pitch + state.crtc->x *
|
|
|
|
state.bpp / 8);
|
2012-07-22 08:55:54 +07:00
|
|
|
}
|
|
|
|
|
2015-08-20 11:54:18 +07:00
|
|
|
return NVIF_NOTIFY_KEEP;
|
2012-07-22 08:55:54 +07:00
|
|
|
}
|
|
|
|
|
2011-09-30 05:55:50 +07:00
|
|
|
int
|
|
|
|
nouveau_display_dumb_create(struct drm_file *file_priv, struct drm_device *dev,
|
|
|
|
struct drm_mode_create_dumb *args)
|
|
|
|
{
|
2016-05-24 14:29:55 +07:00
|
|
|
struct nouveau_cli *cli = nouveau_cli(file_priv);
|
2011-09-30 05:55:50 +07:00
|
|
|
struct nouveau_bo *bo;
|
2015-02-20 16:22:59 +07:00
|
|
|
uint32_t domain;
|
2011-09-30 05:55:50 +07:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
args->pitch = roundup(args->width * (args->bpp / 8), 256);
|
|
|
|
args->size = args->pitch * args->height;
|
|
|
|
args->size = roundup(args->size, PAGE_SIZE);
|
|
|
|
|
2015-02-20 16:22:59 +07:00
|
|
|
/* Use VRAM if there is any ; otherwise fallback to system memory */
|
2016-05-18 10:57:42 +07:00
|
|
|
if (nouveau_drm(dev)->client.device.info.ram_size != 0)
|
2015-02-20 16:22:59 +07:00
|
|
|
domain = NOUVEAU_GEM_DOMAIN_VRAM;
|
|
|
|
else
|
|
|
|
domain = NOUVEAU_GEM_DOMAIN_GART;
|
|
|
|
|
2016-05-24 14:29:55 +07:00
|
|
|
ret = nouveau_gem_new(cli, args->size, 0, domain, 0, 0, &bo);
|
2011-09-30 05:55:50 +07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2013-10-02 15:15:17 +07:00
|
|
|
ret = drm_gem_handle_create(file_priv, &bo->gem, &args->handle);
|
|
|
|
drm_gem_object_unreference_unlocked(&bo->gem);
|
2011-09-30 05:55:50 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
nouveau_display_dumb_map_offset(struct drm_file *file_priv,
|
|
|
|
struct drm_device *dev,
|
|
|
|
uint32_t handle, uint64_t *poffset)
|
|
|
|
{
|
|
|
|
struct drm_gem_object *gem;
|
|
|
|
|
2016-05-09 17:04:54 +07:00
|
|
|
gem = drm_gem_object_lookup(file_priv, handle);
|
2011-09-30 05:55:50 +07:00
|
|
|
if (gem) {
|
2013-10-02 15:15:17 +07:00
|
|
|
struct nouveau_bo *bo = nouveau_gem_object(gem);
|
2013-07-25 02:08:53 +07:00
|
|
|
*poffset = drm_vma_node_offset_addr(&bo->bo.vma_node);
|
2011-09-30 05:55:50 +07:00
|
|
|
drm_gem_object_unreference_unlocked(gem);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -ENOENT;
|
|
|
|
}
|