2009-12-11 09:24:15 +00: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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2012-10-02 17:01:07 +00:00
|
|
|
#include <drm/drmP.h>
|
|
|
|
#include <drm/drm_crtc_helper.h>
|
2012-07-31 06:16:21 +00:00
|
|
|
|
2014-08-09 18:10:23 +00:00
|
|
|
#include <nvif/class.h>
|
|
|
|
|
2009-12-11 09:24:15 +00:00
|
|
|
#include "nouveau_fbcon.h"
|
2013-03-21 05:45:11 +00:00
|
|
|
#include "dispnv04/hw.h"
|
2010-10-20 21:35:40 +00:00
|
|
|
#include "nouveau_crtc.h"
|
|
|
|
#include "nouveau_dma.h"
|
2012-07-31 06:16:21 +00:00
|
|
|
#include "nouveau_gem.h"
|
2011-10-17 02:23:41 +00:00
|
|
|
#include "nouveau_connector.h"
|
2011-02-09 01:57:45 +00:00
|
|
|
#include "nv50_display.h"
|
2009-12-11 09:24:15 +00:00
|
|
|
|
2012-07-19 22:17:34 +00:00
|
|
|
#include "nouveau_fence.h"
|
|
|
|
|
2014-08-09 18:10:20 +00:00
|
|
|
#include <nvif/event.h>
|
2013-01-30 23:23:34 +00:00
|
|
|
|
2013-10-02 21:02:29 +00:00
|
|
|
static int
|
2014-08-09 18:10:20 +00:00
|
|
|
nouveau_display_vblank_handler(struct nvkm_notify *notify)
|
2013-10-02 21:02:29 +00:00
|
|
|
{
|
2014-08-09 18:10:20 +00:00
|
|
|
struct nouveau_crtc *nv_crtc =
|
|
|
|
container_of(notify, typeof(*nv_crtc), vblank);
|
2014-08-09 18:10:19 +00:00
|
|
|
drm_handle_vblank(nv_crtc->base.dev, nv_crtc->index);
|
2014-08-09 18:10:20 +00:00
|
|
|
return NVKM_NOTIFY_KEEP;
|
2013-10-02 21:02:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
nouveau_display_vblank_enable(struct drm_device *dev, int head)
|
|
|
|
{
|
2014-08-09 18:10:19 +00:00
|
|
|
struct drm_crtc *crtc;
|
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
|
|
|
|
if (nv_crtc->index == head) {
|
2014-08-09 18:10:20 +00:00
|
|
|
nvkm_notify_get(&nv_crtc->vblank);
|
2014-08-09 18:10:19 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2013-10-02 21:02:29 +00:00
|
|
|
}
|
2014-08-09 18:10:19 +00:00
|
|
|
return -EINVAL;
|
2013-10-02 21:02:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nouveau_display_vblank_disable(struct drm_device *dev, int head)
|
|
|
|
{
|
2014-08-09 18:10:19 +00:00
|
|
|
struct drm_crtc *crtc;
|
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
|
|
|
|
if (nv_crtc->index == head) {
|
2014-08-09 18:10:20 +00:00
|
|
|
nvkm_notify_put(&nv_crtc->vblank);
|
2014-08-09 18:10:19 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2013-10-02 21:02:29 +00:00
|
|
|
}
|
|
|
|
|
2013-11-14 03:37:49 +00: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;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
nouveau_display_scanoutpos_head(struct drm_crtc *crtc, int *vpos, int *hpos,
|
|
|
|
ktime_t *stime, ktime_t *etime)
|
|
|
|
{
|
|
|
|
const u32 mthd = NV04_DISP_SCANOUTPOS + nouveau_crtc(crtc)->index;
|
|
|
|
struct nouveau_display *disp = nouveau_display(crtc->dev);
|
|
|
|
struct nv04_display_scanoutpos args;
|
|
|
|
int ret, retry = 1;
|
|
|
|
|
|
|
|
do {
|
2014-08-09 18:10:22 +00:00
|
|
|
ret = nvif_exec(&disp->disp, mthd, &args, sizeof(args));
|
2013-11-14 03:37:49 +00:00
|
|
|
if (ret != 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (args.vline) {
|
|
|
|
ret |= DRM_SCANOUTPOS_ACCURATE;
|
|
|
|
ret |= DRM_SCANOUTPOS_VALID;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (retry) ndelay(crtc->linedur_ns);
|
|
|
|
} while (retry--);
|
|
|
|
|
2014-03-19 09:02:11 +00:00
|
|
|
*hpos = args.hline;
|
2013-11-14 03:37:49 +00:00
|
|
|
*vpos = calc(args.vblanks, args.vblanke, args.vtotal, args.vline);
|
|
|
|
if (stime) *stime = ns_to_ktime(args.time[0]);
|
|
|
|
if (etime) *etime = ns_to_ktime(args.time[1]);
|
|
|
|
|
|
|
|
if (*vpos < 0)
|
|
|
|
ret |= DRM_SCANOUTPOS_INVBL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
nouveau_display_scanoutpos(struct drm_device *dev, int head, unsigned int flags,
|
|
|
|
int *vpos, int *hpos, ktime_t *stime, ktime_t *etime)
|
|
|
|
{
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
if (nouveau_crtc(crtc)->index == head) {
|
|
|
|
return nouveau_display_scanoutpos_head(crtc, vpos, hpos,
|
|
|
|
stime, etime);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
nouveau_display_vblstamp(struct drm_device *dev, int head, int *max_error,
|
|
|
|
struct timeval *time, unsigned flags)
|
|
|
|
{
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
if (nouveau_crtc(crtc)->index == head) {
|
|
|
|
return drm_calc_vbltimestamp_from_scanoutpos(dev,
|
|
|
|
head, max_error, time, flags, crtc,
|
|
|
|
&crtc->hwmode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2013-10-02 21:02:29 +00:00
|
|
|
static void
|
|
|
|
nouveau_display_vblank_fini(struct drm_device *dev)
|
|
|
|
{
|
2014-08-09 18:10:19 +00:00
|
|
|
struct drm_crtc *crtc;
|
2013-10-02 21:02:29 +00:00
|
|
|
|
2014-01-23 00:49:47 +00:00
|
|
|
drm_vblank_cleanup(dev);
|
|
|
|
|
2014-08-09 18:10:19 +00:00
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
|
2014-08-09 18:10:20 +00:00
|
|
|
nvkm_notify_fini(&nv_crtc->vblank);
|
2013-10-02 21:02:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
nouveau_display_vblank_init(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct nouveau_drm *drm = nouveau_drm(dev);
|
2014-08-09 18:10:22 +00:00
|
|
|
struct nouveau_disp *pdisp = nvkm_disp(&drm->device);
|
2014-08-09 18:10:19 +00:00
|
|
|
struct drm_crtc *crtc;
|
|
|
|
int ret;
|
2013-10-02 21:02:29 +00:00
|
|
|
|
2014-08-09 18:10:19 +00:00
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
|
2014-08-09 18:10:20 +00:00
|
|
|
ret = nvkm_notify_init(&pdisp->vblank,
|
|
|
|
nouveau_display_vblank_handler, false,
|
|
|
|
&(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-02 21:02:29 +00: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 09:24:15 +00:00
|
|
|
static void
|
|
|
|
nouveau_user_framebuffer_destroy(struct drm_framebuffer *drm_fb)
|
|
|
|
{
|
|
|
|
struct nouveau_framebuffer *fb = nouveau_framebuffer(drm_fb);
|
2014-08-09 18:10:19 +00:00
|
|
|
struct nouveau_display *disp = nouveau_display(drm_fb->dev);
|
|
|
|
|
|
|
|
if (disp->fb_dtor)
|
|
|
|
disp->fb_dtor(drm_fb);
|
2009-12-11 09:24:15 +00:00
|
|
|
|
2010-02-09 05:49:12 +00:00
|
|
|
if (fb->nvbo)
|
2013-10-02 08:15:17 +00:00
|
|
|
drm_gem_object_unreference_unlocked(&fb->nvbo->gem);
|
2009-12-11 09:24:15 +00: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 08:15:17 +00:00
|
|
|
return drm_gem_handle_create(file_priv, &fb->nvbo->gem, handle);
|
2009-12-11 09:24:15 +00: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 05:34:13 +00:00
|
|
|
int
|
2011-02-09 01:57:45 +00:00
|
|
|
nouveau_framebuffer_init(struct drm_device *dev,
|
|
|
|
struct nouveau_framebuffer *nv_fb,
|
2011-11-14 22:51:28 +00:00
|
|
|
struct drm_mode_fb_cmd2 *mode_cmd,
|
2011-02-09 01:57:45 +00:00
|
|
|
struct nouveau_bo *nvbo)
|
2009-12-11 09:24:15 +00:00
|
|
|
{
|
2014-08-09 18:10:19 +00:00
|
|
|
struct nouveau_display *disp = nouveau_display(dev);
|
2011-02-09 01:57:45 +00:00
|
|
|
struct drm_framebuffer *fb = &nv_fb->base;
|
2009-12-11 09:24:15 +00:00
|
|
|
int ret;
|
|
|
|
|
2011-02-09 01:57:45 +00:00
|
|
|
drm_helper_mode_fill_fb_struct(fb, mode_cmd);
|
|
|
|
nv_fb->nvbo = nvbo;
|
|
|
|
|
2012-12-13 22:38:38 +00:00
|
|
|
ret = drm_framebuffer_init(dev, fb, &nouveau_framebuffer_funcs);
|
2014-08-09 18:10:19 +00:00
|
|
|
if (ret)
|
2012-12-13 22:38:38 +00:00
|
|
|
return ret;
|
2014-08-09 18:10:19 +00:00
|
|
|
|
|
|
|
if (disp->fb_ctor) {
|
|
|
|
ret = disp->fb_ctor(fb);
|
|
|
|
if (ret)
|
|
|
|
disp->fb_dtor(fb);
|
2012-12-13 22:38:38 +00:00
|
|
|
}
|
|
|
|
|
2014-08-09 18:10:19 +00:00
|
|
|
return ret;
|
2009-12-11 09:24:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct drm_framebuffer *
|
|
|
|
nouveau_user_framebuffer_create(struct drm_device *dev,
|
|
|
|
struct drm_file *file_priv,
|
2011-11-14 22:51:28 +00:00
|
|
|
struct drm_mode_fb_cmd2 *mode_cmd)
|
2009-12-11 09:24:15 +00:00
|
|
|
{
|
2010-03-30 05:34:13 +00:00
|
|
|
struct nouveau_framebuffer *nouveau_fb;
|
2009-12-11 09:24:15 +00:00
|
|
|
struct drm_gem_object *gem;
|
2013-07-08 04:50:54 +00:00
|
|
|
int ret = -ENOMEM;
|
2009-12-11 09:24:15 +00:00
|
|
|
|
2011-11-14 22:51:28 +00:00
|
|
|
gem = drm_gem_object_lookup(dev, file_priv, mode_cmd->handles[0]);
|
2009-12-11 09:24:15 +00:00
|
|
|
if (!gem)
|
2010-08-08 12:36:38 +00:00
|
|
|
return ERR_PTR(-ENOENT);
|
2009-12-11 09:24:15 +00:00
|
|
|
|
2010-03-30 05:34:13 +00:00
|
|
|
nouveau_fb = kzalloc(sizeof(struct nouveau_framebuffer), GFP_KERNEL);
|
|
|
|
if (!nouveau_fb)
|
2013-07-08 04:50:54 +00:00
|
|
|
goto err_unref;
|
2010-03-30 05:34:13 +00:00
|
|
|
|
|
|
|
ret = nouveau_framebuffer_init(dev, nouveau_fb, mode_cmd, nouveau_gem_object(gem));
|
2013-07-08 04:50:54 +00:00
|
|
|
if (ret)
|
|
|
|
goto err;
|
2009-12-11 09:24:15 +00:00
|
|
|
|
2010-03-30 05:34:13 +00:00
|
|
|
return &nouveau_fb->base;
|
2013-07-08 04:50:54 +00:00
|
|
|
|
|
|
|
err:
|
|
|
|
kfree(nouveau_fb);
|
|
|
|
err_unref:
|
|
|
|
drm_gem_object_unreference(gem);
|
|
|
|
return ERR_PTR(ret);
|
2009-12-11 09:24:15 +00:00
|
|
|
}
|
|
|
|
|
2011-10-06 02:46:40 +00:00
|
|
|
static const struct drm_mode_config_funcs nouveau_mode_config_funcs = {
|
2009-12-11 09:24:15 +00:00
|
|
|
.fb_create = nouveau_user_framebuffer_create,
|
2010-05-07 06:42:51 +00:00
|
|
|
.output_poll_changed = nouveau_fbcon_output_poll_changed,
|
2009-12-11 09:24:15 +00:00
|
|
|
};
|
|
|
|
|
2011-10-06 03:29:05 +00:00
|
|
|
|
2012-02-06 09:58:17 +00:00
|
|
|
struct nouveau_drm_prop_enum_list {
|
2011-10-17 02:23:41 +00:00
|
|
|
u8 gen_mask;
|
2011-10-06 03:29:05 +00:00
|
|
|
int type;
|
|
|
|
char *name;
|
|
|
|
};
|
|
|
|
|
2012-02-06 09:58:17 +00:00
|
|
|
static struct nouveau_drm_prop_enum_list underscan[] = {
|
2011-11-11 13:49:06 +00:00
|
|
|
{ 6, UNDERSCAN_AUTO, "auto" },
|
|
|
|
{ 6, UNDERSCAN_OFF, "off" },
|
|
|
|
{ 6, UNDERSCAN_ON, "on" },
|
2011-10-17 02:23:41 +00:00
|
|
|
{}
|
2011-10-06 03:29:05 +00:00
|
|
|
};
|
|
|
|
|
2012-02-06 09:58:17 +00:00
|
|
|
static struct nouveau_drm_prop_enum_list dither_mode[] = {
|
2011-10-17 02:23:41 +00: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 09:58:17 +00:00
|
|
|
static struct nouveau_drm_prop_enum_list dither_depth[] = {
|
2011-10-17 02:23:41 +00: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 09:58:17 +00:00
|
|
|
struct nouveau_drm_prop_enum_list *l = (list); \
|
2011-10-17 02:23:41 +00: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)
|
|
|
|
|
2011-11-09 05:18:47 +00:00
|
|
|
int
|
|
|
|
nouveau_display_init(struct drm_device *dev)
|
|
|
|
{
|
2012-07-31 06:16:21 +00:00
|
|
|
struct nouveau_display *disp = nouveau_display(dev);
|
2011-11-24 02:59:44 +00:00
|
|
|
struct drm_connector *connector;
|
2011-11-09 05:18:47 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = disp->init(dev);
|
2011-11-24 02:59:44 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2012-01-30 23:16:59 +00:00
|
|
|
/* enable polling for external displays */
|
2011-11-24 02:59:44 +00:00
|
|
|
drm_kms_helper_poll_enable(dev);
|
|
|
|
|
|
|
|
/* enable hotplug interrupts */
|
|
|
|
list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
|
|
|
|
struct nouveau_connector *conn = nouveau_connector(connector);
|
2014-08-09 18:10:20 +00:00
|
|
|
nvkm_notify_get(&conn->hpd);
|
2011-11-09 05:18:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nouveau_display_fini(struct drm_device *dev)
|
|
|
|
{
|
2012-07-31 06:16:21 +00:00
|
|
|
struct nouveau_display *disp = nouveau_display(dev);
|
2011-11-24 02:59:44 +00:00
|
|
|
struct drm_connector *connector;
|
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 00:36:44 +00:00
|
|
|
int head;
|
|
|
|
|
|
|
|
/* Make sure that drm and hw vblank irqs get properly disabled. */
|
|
|
|
for (head = 0; head < dev->mode_config.num_crtc; head++)
|
|
|
|
drm_vblank_off(dev, head);
|
2011-11-24 02:59:44 +00:00
|
|
|
|
|
|
|
/* disable hotplug interrupts */
|
|
|
|
list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
|
|
|
|
struct nouveau_connector *conn = nouveau_connector(connector);
|
2014-08-09 18:10:20 +00:00
|
|
|
nvkm_notify_put(&conn->hpd);
|
2011-11-24 02:59:44 +00:00
|
|
|
}
|
2011-11-09 05:18:47 +00:00
|
|
|
|
|
|
|
drm_kms_helper_poll_disable(dev);
|
|
|
|
disp->fini(dev);
|
|
|
|
}
|
|
|
|
|
2014-08-09 18:10:21 +00:00
|
|
|
static void
|
|
|
|
nouveau_display_create_properties(struct drm_device *dev)
|
2011-10-06 02:46:40 +00:00
|
|
|
{
|
2014-08-09 18:10:21 +00:00
|
|
|
struct nouveau_display *disp = nouveau_display(dev);
|
|
|
|
int gen;
|
2011-10-17 02:23:41 +00:00
|
|
|
|
2014-08-09 18:10:22 +00:00
|
|
|
if (disp->disp.oclass < NV50_DISP_CLASS)
|
2011-10-17 02:23:41 +00:00
|
|
|
gen = 0;
|
|
|
|
else
|
2014-08-09 18:10:22 +00:00
|
|
|
if (disp->disp.oclass < NVD0_DISP_CLASS)
|
2011-10-17 02:23:41 +00: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 03:29:05 +00:00
|
|
|
|
|
|
|
disp->underscan_hborder_property =
|
2012-02-06 09:58:18 +00:00
|
|
|
drm_property_create_range(dev, 0, "underscan hborder", 0, 128);
|
2011-10-06 03:29:05 +00:00
|
|
|
|
|
|
|
disp->underscan_vborder_property =
|
2012-02-06 09:58:18 +00:00
|
|
|
drm_property_create_range(dev, 0, "underscan vborder", 0, 128);
|
2011-10-06 03:29:05 +00:00
|
|
|
|
2014-08-09 18:10:21 +00:00
|
|
|
if (gen < 1)
|
|
|
|
return;
|
2012-01-21 22:13:26 +00:00
|
|
|
|
2014-08-09 18:10:21 +00: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);
|
|
|
|
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-21 22:13:26 +00:00
|
|
|
|
2012-05-17 11:27:23 +00:00
|
|
|
dev->mode_config.funcs = &nouveau_mode_config_funcs;
|
2014-08-09 18:10:22 +00:00
|
|
|
dev->mode_config.fb_base = nv_device_resource_start(nvkm_device(&drm->device), 1);
|
2011-10-06 02:46:40 +00:00
|
|
|
|
|
|
|
dev->mode_config.min_width = 0;
|
|
|
|
dev->mode_config.min_height = 0;
|
2014-08-09 18:10:22 +00:00
|
|
|
if (drm->device.info.family < NV_DEVICE_INFO_V0_CELSIUS) {
|
2011-10-06 02:46:40 +00:00
|
|
|
dev->mode_config.max_width = 2048;
|
|
|
|
dev->mode_config.max_height = 2048;
|
|
|
|
} else
|
2014-08-09 18:10:22 +00:00
|
|
|
if (drm->device.info.family < NV_DEVICE_INFO_V0_TESLA) {
|
2011-10-06 02:46:40 +00:00
|
|
|
dev->mode_config.max_width = 4096;
|
|
|
|
dev->mode_config.max_height = 4096;
|
|
|
|
} else {
|
|
|
|
dev->mode_config.max_width = 8192;
|
|
|
|
dev->mode_config.max_height = 8192;
|
|
|
|
}
|
|
|
|
|
2012-02-20 14:39:11 +00:00
|
|
|
dev->mode_config.preferred_depth = 24;
|
|
|
|
dev->mode_config.prefer_shadow = 1;
|
|
|
|
|
2014-08-09 18:10:22 +00:00
|
|
|
if (drm->device.info.chipset < 0x11)
|
2013-11-11 03:59:40 +00:00
|
|
|
dev->mode_config.async_page_flip = false;
|
|
|
|
else
|
|
|
|
dev->mode_config.async_page_flip = true;
|
|
|
|
|
2011-11-09 05:18:47 +00:00
|
|
|
drm_kms_helper_poll_init(dev);
|
|
|
|
drm_kms_helper_poll_disable(dev);
|
|
|
|
|
2013-09-10 03:20:34 +00:00
|
|
|
if (drm->vbios.dcb.entries) {
|
2014-01-22 02:58:12 +00:00
|
|
|
static const u16 oclass[] = {
|
2014-02-24 04:29:55 +00:00
|
|
|
GM107_DISP_CLASS,
|
2014-01-22 02:58:12 +00:00
|
|
|
NVF0_DISP_CLASS,
|
|
|
|
NVE0_DISP_CLASS,
|
|
|
|
NVD0_DISP_CLASS,
|
|
|
|
NVA3_DISP_CLASS,
|
|
|
|
NV94_DISP_CLASS,
|
|
|
|
NVA0_DISP_CLASS,
|
|
|
|
NV84_DISP_CLASS,
|
|
|
|
NV50_DISP_CLASS,
|
|
|
|
NV04_DISP_CLASS,
|
|
|
|
};
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0, ret = -ENODEV; ret && i < ARRAY_SIZE(oclass); i++) {
|
2014-08-09 18:10:22 +00:00
|
|
|
ret = nvif_object_init(nvif_object(&drm->device), NULL,
|
|
|
|
NVDRM_DISPLAY, oclass[i],
|
|
|
|
NULL, 0, &disp->disp);
|
2014-01-22 02:58:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ret == 0) {
|
2014-08-09 18:10:21 +00:00
|
|
|
nouveau_display_create_properties(dev);
|
2014-08-09 18:10:22 +00:00
|
|
|
if (disp->disp.oclass < NV50_DISP_CLASS)
|
2014-01-22 02:58:12 +00:00
|
|
|
ret = nv04_display_create(dev);
|
|
|
|
else
|
|
|
|
ret = nv50_display_create(dev);
|
|
|
|
}
|
2013-09-10 03:20:34 +00:00
|
|
|
} else {
|
|
|
|
ret = 0;
|
|
|
|
}
|
2012-10-31 02:11:15 +00:00
|
|
|
|
2013-09-10 03:20:34 +00:00
|
|
|
if (ret)
|
|
|
|
goto disp_create_err;
|
2012-10-31 02:11:15 +00:00
|
|
|
|
2013-09-10 03:20:34 +00:00
|
|
|
if (dev->mode_config.num_crtc) {
|
2013-10-02 21:02:29 +00:00
|
|
|
ret = nouveau_display_vblank_init(dev);
|
2013-09-10 03:20:34 +00:00
|
|
|
if (ret)
|
|
|
|
goto vblank_err;
|
2011-11-09 05:18:47 +00:00
|
|
|
}
|
|
|
|
|
2013-09-10 03:20:34 +00:00
|
|
|
nouveau_backlight_init(dev);
|
2012-04-15 12:36:08 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
vblank_err:
|
2012-07-31 06:16:21 +00:00
|
|
|
disp->dtor(dev);
|
2012-04-15 12:36:08 +00:00
|
|
|
disp_create_err:
|
|
|
|
drm_kms_helper_poll_fini(dev);
|
|
|
|
drm_mode_config_cleanup(dev);
|
2011-11-09 01:36:33 +00:00
|
|
|
return ret;
|
2011-10-06 02:46:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nouveau_display_destroy(struct drm_device *dev)
|
|
|
|
{
|
2012-07-31 06:16:21 +00:00
|
|
|
struct nouveau_display *disp = nouveau_display(dev);
|
2011-10-06 02:46:40 +00:00
|
|
|
|
2012-07-31 06:16:21 +00:00
|
|
|
nouveau_backlight_exit(dev);
|
2013-10-02 21:02:29 +00:00
|
|
|
nouveau_display_vblank_fini(dev);
|
2011-11-09 05:18:47 +00:00
|
|
|
|
2012-10-30 00:59:12 +00:00
|
|
|
drm_kms_helper_poll_fini(dev);
|
|
|
|
drm_mode_config_cleanup(dev);
|
|
|
|
|
2012-10-31 02:11:15 +00:00
|
|
|
if (disp->dtor)
|
|
|
|
disp->dtor(dev);
|
2011-11-09 05:18:47 +00:00
|
|
|
|
2014-08-09 18:10:22 +00:00
|
|
|
nvif_object_fini(&disp->disp);
|
2014-01-22 02:58:12 +00:00
|
|
|
|
2012-07-31 06:16:21 +00:00
|
|
|
nouveau_drm(dev)->display = NULL;
|
|
|
|
kfree(disp);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
nouveau_display_suspend(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct nouveau_drm *drm = nouveau_drm(dev);
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
|
|
|
nouveau_display_fini(dev);
|
|
|
|
|
2013-11-08 04:38:40 +00:00
|
|
|
NV_INFO(drm, "unpinning framebuffer(s)...\n");
|
2012-07-31 06:16:21 +00:00
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
struct nouveau_framebuffer *nouveau_fb;
|
|
|
|
|
2014-04-01 22:22:40 +00:00
|
|
|
nouveau_fb = nouveau_framebuffer(crtc->primary->fb);
|
2012-07-31 06:16:21 +00: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);
|
|
|
|
|
|
|
|
nouveau_bo_unmap(nv_crtc->cursor.nvbo);
|
|
|
|
nouveau_bo_unpin(nv_crtc->cursor.nvbo);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2012-09-10 04:20:51 +00:00
|
|
|
nouveau_display_repin(struct drm_device *dev)
|
2012-07-31 06:16:21 +00:00
|
|
|
{
|
|
|
|
struct nouveau_drm *drm = nouveau_drm(dev);
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
struct nouveau_framebuffer *nouveau_fb;
|
|
|
|
|
2014-04-01 22:22:40 +00:00
|
|
|
nouveau_fb = nouveau_framebuffer(crtc->primary->fb);
|
2012-07-31 06:16:21 +00:00
|
|
|
if (!nouveau_fb || !nouveau_fb->nvbo)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
nouveau_bo_pin(nouveau_fb->nvbo, TTM_PL_FLAG_VRAM);
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
|
|
|
|
|
|
|
|
ret = nouveau_bo_pin(nv_crtc->cursor.nvbo, TTM_PL_FLAG_VRAM);
|
|
|
|
if (!ret)
|
|
|
|
ret = nouveau_bo_map(nv_crtc->cursor.nvbo);
|
|
|
|
if (ret)
|
|
|
|
NV_ERROR(drm, "Could not pin/map cursor.\n");
|
|
|
|
}
|
2012-09-10 04:20:51 +00:00
|
|
|
}
|
2012-07-31 06:16:21 +00:00
|
|
|
|
2012-09-10 04:20:51 +00:00
|
|
|
void
|
|
|
|
nouveau_display_resume(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
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 00:36:44 +00:00
|
|
|
int head;
|
|
|
|
|
2012-07-31 06:16:21 +00: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;
|
|
|
|
}
|
|
|
|
|
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 00:36:44 +00:00
|
|
|
/* Make sure that drm and hw vblank irqs get resumed if needed. */
|
|
|
|
for (head = 0; head < dev->mode_config.num_crtc; head++)
|
|
|
|
drm_vblank_on(dev, head);
|
|
|
|
|
2012-07-31 06:16:21 +00: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);
|
|
|
|
u32 offset = nv_crtc->cursor.nvbo->bo.offset;
|
|
|
|
|
|
|
|
nv_crtc->cursor.set_offset(nv_crtc, offset);
|
|
|
|
nv_crtc->cursor.set_pos(nv_crtc, nv_crtc->cursor_saved_x,
|
|
|
|
nv_crtc->cursor_saved_y);
|
|
|
|
}
|
2011-10-06 02:46:40 +00:00
|
|
|
}
|
|
|
|
|
2010-10-20 21:35:40 +00: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 01:55:54 +00:00
|
|
|
struct nouveau_fence_chan *fctx = chan->fence;
|
2012-07-31 06:16:21 +00:00
|
|
|
struct nouveau_drm *drm = chan->drm;
|
|
|
|
struct drm_device *dev = drm->dev;
|
2010-10-20 21:35:40 +00:00
|
|
|
unsigned long flags;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Queue it to the pending list */
|
|
|
|
spin_lock_irqsave(&dev->event_lock, flags);
|
2012-07-22 01:55:54 +00:00
|
|
|
list_add_tail(&s->head, &fctx->flip);
|
2010-10-20 21:35:40 +00:00
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
|
|
|
|
|
|
|
/* Synchronize with the old framebuffer */
|
|
|
|
ret = nouveau_fence_sync(old_bo->bo.sync_obj, chan);
|
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
/* Emit the pageflip */
|
2013-11-13 00:49:46 +00:00
|
|
|
ret = RING_SPACE(chan, 2);
|
2010-10-20 21:35:40 +00:00
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
|
2014-08-09 18:10:22 +00:00
|
|
|
if (drm->device.info.family < NV_DEVICE_INFO_V0_FERMI)
|
2012-04-01 11:09:13 +00:00
|
|
|
BEGIN_NV04(chan, NvSubSw, NV_SW_PAGE_FLIP, 1);
|
2013-11-13 00:49:46 +00:00
|
|
|
else
|
|
|
|
BEGIN_NVC0(chan, FermiSw, NV_SW_PAGE_FLIP, 1);
|
|
|
|
OUT_RING (chan, 0x00000000);
|
2011-02-08 05:16:23 +00:00
|
|
|
FIRE_RING (chan);
|
2010-10-20 21:35:40 +00:00
|
|
|
|
2013-02-14 03:43:21 +00:00
|
|
|
ret = nouveau_fence_new(chan, false, pfence);
|
2010-10-20 21:35:40 +00: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,
|
2013-11-11 03:59:40 +00:00
|
|
|
struct drm_pending_vblank_event *event, u32 flags)
|
2010-10-20 21:35:40 +00:00
|
|
|
{
|
2013-11-11 03:59:40 +00:00
|
|
|
const int swap_interval = (flags & DRM_MODE_PAGE_FLIP_ASYNC) ? 0 : 1;
|
2010-10-20 21:35:40 +00:00
|
|
|
struct drm_device *dev = crtc->dev;
|
2012-07-31 06:16:21 +00:00
|
|
|
struct nouveau_drm *drm = nouveau_drm(dev);
|
2014-04-01 22:22:40 +00:00
|
|
|
struct nouveau_bo *old_bo = nouveau_framebuffer(crtc->primary->fb)->nvbo;
|
2010-10-20 21:35:40 +00:00
|
|
|
struct nouveau_bo *new_bo = nouveau_framebuffer(fb)->nvbo;
|
|
|
|
struct nouveau_page_flip_state *s;
|
2014-08-09 18:10:22 +00:00
|
|
|
struct nouveau_channel *chan;
|
|
|
|
struct nouveau_cli *cli;
|
2010-10-20 21:35:40 +00:00
|
|
|
struct nouveau_fence *fence;
|
|
|
|
int ret;
|
|
|
|
|
2014-08-09 18:10:22 +00:00
|
|
|
chan = drm->channel;
|
|
|
|
if (!chan)
|
2010-10-20 21:35:40 +00:00
|
|
|
return -ENODEV;
|
2014-08-09 18:10:22 +00:00
|
|
|
cli = (void *)nvif_client(&chan->device->base);
|
2010-10-20 21:35:40 +00:00
|
|
|
|
|
|
|
s = kzalloc(sizeof(*s), GFP_KERNEL);
|
|
|
|
if (!s)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2014-01-14 15:48:58 +00:00
|
|
|
if (new_bo != old_bo) {
|
|
|
|
ret = nouveau_bo_pin(new_bo, TTM_PL_FLAG_VRAM);
|
|
|
|
if (ret)
|
|
|
|
goto fail_free;
|
|
|
|
}
|
|
|
|
|
2014-08-09 18:10:22 +00:00
|
|
|
mutex_lock(&cli->mutex);
|
2014-01-14 15:48:58 +00:00
|
|
|
|
2013-11-13 00:17:17 +00:00
|
|
|
/* synchronise rendering channel with the kernel's channel */
|
|
|
|
spin_lock(&new_bo->bo.bdev->fence_lock);
|
|
|
|
fence = nouveau_fence_ref(new_bo->bo.sync_obj);
|
|
|
|
spin_unlock(&new_bo->bo.bdev->fence_lock);
|
|
|
|
ret = nouveau_fence_sync(fence, chan);
|
2013-11-21 04:22:39 +00:00
|
|
|
nouveau_fence_unref(&fence);
|
2013-11-13 00:17:17 +00:00
|
|
|
if (ret)
|
2014-01-29 10:05:09 +00:00
|
|
|
goto fail_unpin;
|
2013-06-27 11:48:18 +00:00
|
|
|
|
2013-11-13 00:00:32 +00:00
|
|
|
ret = ttm_bo_reserve(&old_bo->bo, true, false, false, NULL);
|
2013-07-08 04:15:51 +00:00
|
|
|
if (ret)
|
|
|
|
goto fail_unpin;
|
2013-06-27 11:48:18 +00:00
|
|
|
|
|
|
|
/* Initialize a page flip struct */
|
|
|
|
*s = (struct nouveau_page_flip_state)
|
|
|
|
{ { }, event, nouveau_crtc(crtc)->index,
|
|
|
|
fb->bits_per_pixel, fb->pitches[0], crtc->x, crtc->y,
|
|
|
|
new_bo->bo.offset };
|
|
|
|
|
2014-06-11 07:51:23 +00:00
|
|
|
/* Keep vblanks on during flip, for the target crtc of this flip */
|
|
|
|
drm_vblank_get(dev, nouveau_crtc(crtc)->index);
|
|
|
|
|
2010-10-20 21:35:40 +00:00
|
|
|
/* Emit a page flip */
|
2014-08-09 18:10:22 +00:00
|
|
|
if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA) {
|
2013-11-11 03:59:40 +00:00
|
|
|
ret = nv50_display_flip_next(crtc, fb, chan, swap_interval);
|
2013-07-08 04:15:51 +00:00
|
|
|
if (ret)
|
2011-02-07 04:27:04 +00:00
|
|
|
goto fail_unreserve;
|
2013-08-21 01:30:36 +00:00
|
|
|
} else {
|
|
|
|
struct nv04_display *dispnv04 = nv04_display(dev);
|
2013-11-11 03:59:40 +00:00
|
|
|
int head = nouveau_crtc(crtc)->index;
|
|
|
|
|
|
|
|
if (swap_interval) {
|
|
|
|
ret = RING_SPACE(chan, 8);
|
|
|
|
if (ret)
|
|
|
|
goto fail_unreserve;
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
nouveau_bo_ref(new_bo, &dispnv04->image[head]);
|
2011-02-07 04:27:04 +00:00
|
|
|
}
|
|
|
|
|
2010-10-20 21:35:40 +00:00
|
|
|
ret = nouveau_page_flip_emit(chan, old_bo, new_bo, s, &fence);
|
|
|
|
if (ret)
|
|
|
|
goto fail_unreserve;
|
2014-08-09 18:10:22 +00:00
|
|
|
mutex_unlock(&cli->mutex);
|
2010-10-20 21:35:40 +00:00
|
|
|
|
|
|
|
/* Update the crtc struct and cleanup */
|
2014-04-01 22:22:40 +00:00
|
|
|
crtc->primary->fb = fb;
|
2010-10-20 21:35:40 +00:00
|
|
|
|
2013-11-13 00:00:32 +00:00
|
|
|
nouveau_bo_fence(old_bo, fence);
|
|
|
|
ttm_bo_unreserve(&old_bo->bo);
|
2013-07-08 04:15:51 +00:00
|
|
|
if (old_bo != new_bo)
|
2013-06-27 11:48:18 +00:00
|
|
|
nouveau_bo_unpin(old_bo);
|
2010-10-20 21:35:40 +00:00
|
|
|
nouveau_fence_unref(&fence);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail_unreserve:
|
2014-06-11 07:51:23 +00:00
|
|
|
drm_vblank_put(dev, nouveau_crtc(crtc)->index);
|
2013-11-13 00:00:32 +00:00
|
|
|
ttm_bo_unreserve(&old_bo->bo);
|
2013-07-08 04:15:51 +00:00
|
|
|
fail_unpin:
|
2014-08-09 18:10:22 +00:00
|
|
|
mutex_unlock(&cli->mutex);
|
2013-07-08 04:15:51 +00:00
|
|
|
if (old_bo != new_bo)
|
2013-06-27 11:48:18 +00:00
|
|
|
nouveau_bo_unpin(new_bo);
|
2010-10-20 21:35:40 +00: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 01:55:54 +00:00
|
|
|
struct nouveau_fence_chan *fctx = chan->fence;
|
2012-07-31 06:16:21 +00:00
|
|
|
struct nouveau_drm *drm = chan->drm;
|
|
|
|
struct drm_device *dev = drm->dev;
|
2010-10-20 21:35:40 +00:00
|
|
|
struct nouveau_page_flip_state *s;
|
|
|
|
unsigned long flags;
|
2014-05-12 22:42:08 +00:00
|
|
|
int crtcid = -1;
|
2010-10-20 21:35:40 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&dev->event_lock, flags);
|
|
|
|
|
2012-07-22 01:55:54 +00:00
|
|
|
if (list_empty(&fctx->flip)) {
|
2012-07-31 06:16:21 +00:00
|
|
|
NV_ERROR(drm, "unexpected pageflip\n");
|
2010-10-20 21:35:40 +00:00
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-07-22 01:55:54 +00:00
|
|
|
s = list_first_entry(&fctx->flip, struct nouveau_page_flip_state, head);
|
2014-05-12 22:42:08 +00:00
|
|
|
if (s->event) {
|
|
|
|
/* Vblank timestamps/counts are only correct on >= NV-50 */
|
2014-08-09 18:10:22 +00:00
|
|
|
if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA)
|
2014-05-12 22:42:08 +00:00
|
|
|
crtcid = s->crtc;
|
|
|
|
|
|
|
|
drm_send_vblank_event(dev, crtcid, s->event);
|
|
|
|
}
|
2010-10-20 21:35:40 +00:00
|
|
|
|
2014-06-11 07:51:23 +00:00
|
|
|
/* Give up ownership of vblank for page-flipped crtc */
|
|
|
|
drm_vblank_put(dev, s->crtc);
|
|
|
|
|
2010-10-20 21:35:40 +00:00
|
|
|
list_del(&s->head);
|
2011-02-07 04:27:04 +00:00
|
|
|
if (ps)
|
|
|
|
*ps = *s;
|
2010-10-20 21:35:40 +00:00
|
|
|
kfree(s);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
|
|
|
return 0;
|
|
|
|
}
|
2011-09-29 22:55:50 +00:00
|
|
|
|
2012-07-22 01:55:54 +00:00
|
|
|
int
|
|
|
|
nouveau_flip_complete(void *data)
|
|
|
|
{
|
|
|
|
struct nouveau_channel *chan = data;
|
2012-07-31 06:16:21 +00:00
|
|
|
struct nouveau_drm *drm = chan->drm;
|
2012-07-22 01:55:54 +00:00
|
|
|
struct nouveau_page_flip_state state;
|
|
|
|
|
|
|
|
if (!nouveau_finish_page_flip(chan, &state)) {
|
2014-08-09 18:10:22 +00:00
|
|
|
if (drm->device.info.family < NV_DEVICE_INFO_V0_TESLA) {
|
2012-07-31 06:16:21 +00:00
|
|
|
nv_set_crtc_base(drm->dev, state.crtc, state.offset +
|
2012-07-22 01:55:54 +00:00
|
|
|
state.y * state.pitch +
|
|
|
|
state.x * state.bpp / 8);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-09-29 22:55:50 +00:00
|
|
|
int
|
|
|
|
nouveau_display_dumb_create(struct drm_file *file_priv, struct drm_device *dev,
|
|
|
|
struct drm_mode_create_dumb *args)
|
|
|
|
{
|
|
|
|
struct nouveau_bo *bo;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
args->pitch = roundup(args->width * (args->bpp / 8), 256);
|
|
|
|
args->size = args->pitch * args->height;
|
|
|
|
args->size = roundup(args->size, PAGE_SIZE);
|
|
|
|
|
2012-09-14 03:28:23 +00:00
|
|
|
ret = nouveau_gem_new(dev, args->size, 0, NOUVEAU_GEM_DOMAIN_VRAM, 0, 0, &bo);
|
2011-09-29 22:55:50 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2013-10-02 08:15:17 +00:00
|
|
|
ret = drm_gem_handle_create(file_priv, &bo->gem, &args->handle);
|
|
|
|
drm_gem_object_unreference_unlocked(&bo->gem);
|
2011-09-29 22:55:50 +00: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;
|
|
|
|
|
|
|
|
gem = drm_gem_object_lookup(dev, file_priv, handle);
|
|
|
|
if (gem) {
|
2013-10-02 08:15:17 +00:00
|
|
|
struct nouveau_bo *bo = nouveau_gem_object(gem);
|
2013-07-24 19:08:53 +00:00
|
|
|
*poffset = drm_vma_node_offset_addr(&bo->bo.vma_node);
|
2011-09-29 22:55:50 +00:00
|
|
|
drm_gem_object_unreference_unlocked(gem);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -ENOENT;
|
|
|
|
}
|