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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2012-10-03 00:01:07 +07:00
|
|
|
#include <drm/drmP.h>
|
|
|
|
#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;
|
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
|
2015-09-24 23:35:31 +07:00
|
|
|
if (nv_crtc->index == pipe) {
|
2014-08-10 01:10:28 +07:00
|
|
|
nvif_notify_get(&nv_crtc->vblank);
|
2014-08-10 01:10:19 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2013-10-03 04:02:29 +07:00
|
|
|
}
|
2014-08-10 01:10:19 +07:00
|
|
|
return -EINVAL;
|
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;
|
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
|
|
|
struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
|
2015-09-24 23:35:31 +07:00
|
|
|
if (nv_crtc->index == pipe) {
|
2014-08-10 01:10:28 +07:00
|
|
|
nvif_notify_put(&nv_crtc->vblank);
|
2014-08-10 01:10:19 +07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
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;
|
|
|
|
}
|
|
|
|
|
2016-10-24 10:09:03 +07:00
|
|
|
static int
|
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)];
|
2013-11-14 10:37:49 +07:00
|
|
|
int ret, retry = 1;
|
|
|
|
|
|
|
|
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)
|
|
|
|
return 0;
|
|
|
|
|
2014-08-10 01:10:27 +07:00
|
|
|
if (args.scan.vline) {
|
2013-11-14 10:37:49 +07:00
|
|
|
ret |= DRM_SCANOUTPOS_ACCURATE;
|
|
|
|
ret |= DRM_SCANOUTPOS_VALID;
|
|
|
|
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
|
|
|
|
|
|
|
if (*vpos < 0)
|
2014-09-10 22:36:11 +07:00
|
|
|
ret |= DRM_SCANOUTPOS_IN_VBLANK;
|
2013-11-14 10:37:49 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2015-09-24 23:35:31 +07:00
|
|
|
nouveau_display_scanoutpos(struct drm_device *dev, unsigned int pipe,
|
|
|
|
unsigned int flags, int *vpos, int *hpos,
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2015-09-24 23:35:31 +07:00
|
|
|
nouveau_display_vblstamp(struct drm_device *dev, unsigned int pipe,
|
|
|
|
int *max_error, struct timeval *time, unsigned flags)
|
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 drm_calc_vbltimestamp_from_scanoutpos(dev,
|
2015-09-24 23:35:31 +07:00
|
|
|
pipe, max_error, time, flags,
|
2013-11-14 10:37:49 +07:00
|
|
|
&crtc->hwmode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
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);
|
2014-08-10 01:10:19 +07:00
|
|
|
struct nouveau_display *disp = nouveau_display(drm_fb->dev);
|
|
|
|
|
|
|
|
if (disp->fb_dtor)
|
|
|
|
disp->fb_dtor(drm_fb);
|
2009-12-11 16:24:15 +07:00
|
|
|
|
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
|
|
|
{
|
2014-08-10 01:10:19 +07:00
|
|
|
struct nouveau_display *disp = nouveau_display(dev);
|
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:35 +07:00
|
|
|
if (!(fb = kzalloc(sizeof(*fb), GFP_KERNEL)))
|
|
|
|
return -ENOMEM;
|
2011-02-09 08:57:45 +07:00
|
|
|
|
2016-11-04 14:20:35 +07:00
|
|
|
drm_helper_mode_fill_fb_struct(&fb->base, mode_cmd);
|
|
|
|
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);
|
|
|
|
if (ret == 0) {
|
|
|
|
if (!disp->fb_ctor || !(ret = disp->fb_ctor(&fb->base))) {
|
|
|
|
*pfb = fb;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
disp->fb_dtor(&fb->base);
|
|
|
|
drm_framebuffer_cleanup(&fb->base);
|
2012-12-14 05:38:38 +07:00
|
|
|
}
|
|
|
|
|
2016-11-04 14:20:35 +07:00
|
|
|
kfree(fb);
|
2014-08-10 01:10:19 +07:00
|
|
|
return ret;
|
2009-12-11 16:24:15 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct drm_framebuffer *
|
|
|
|
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)
|
|
|
|
|
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;
|
|
|
|
|
2012-01-31 06:16:59 +07:00
|
|
|
/* enable polling for external displays */
|
2011-11-24 09:59:44 +07: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-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
|
|
|
|
nouveau_display_fini(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;
|
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
|
|
|
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 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);
|
2015-08-20 11:54:23 +07:00
|
|
|
struct nvkm_device *device = nvxx_device(&drm->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;
|
2014-08-10 01:10:22 +07:00
|
|
|
if (drm->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
|
2014-08-10 01:10:22 +07:00
|
|
|
if (drm->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
|
|
|
|
if (drm->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;
|
|
|
|
|
2014-08-10 01:10:22 +07:00
|
|
|
if (drm->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-07-09 07:41:01 +07:00
|
|
|
GP104_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++) {
|
2015-09-04 11:40:32 +07:00
|
|
|
ret = nvif_object_init(&drm->device.object, 0,
|
|
|
|
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
|
|
|
|
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);
|
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
|
|
|
|
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);
|
2016-06-08 23:47:27 +07:00
|
|
|
drm_crtc_force_disable_all(dev);
|
2012-10-30 07:59:12 +07:00
|
|
|
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
|
|
|
{
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
|
|
|
nouveau_display_fini(dev);
|
|
|
|
|
|
|
|
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
|
|
|
{
|
|
|
|
struct nouveau_drm *drm = nouveau_drm(dev);
|
|
|
|
struct drm_crtc *crtc;
|
2014-10-02 10:22:27 +07:00
|
|
|
int ret, head;
|
2012-07-31 13:16:21 +07:00
|
|
|
|
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);
|
|
|
|
|
2016-02-13 02:30:32 +07: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 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)
|
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;
|
|
|
|
|
2014-08-10 01:10:22 +07:00
|
|
|
if (drm->device.info.family < NV_DEVICE_INFO_V0_FERMI)
|
2012-04-01 18:09:13 +07:00
|
|
|
BEGIN_NV04(chan, NvSubSw, NV_SW_PAGE_FLIP, 1);
|
2013-11-13 07:49:46 +07:00
|
|
|
else
|
|
|
|
BEGIN_NVC0(chan, FermiSw, NV_SW_PAGE_FLIP, 1);
|
|
|
|
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,
|
2013-11-11 10:59:40 +07:00
|
|
|
struct drm_pending_vblank_event *event, u32 flags)
|
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;
|
|
|
|
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-06-07 21:07:53 +07:00
|
|
|
{ { }, event, crtc, fb->bits_per_pixel, 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 */
|
2014-08-10 01:10:22 +07:00
|
|
|
if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA) {
|
2013-11-11 10:59:40 +07:00
|
|
|
ret = nv50_display_flip_next(crtc, fb, chan, swap_interval);
|
2013-07-08 11:15:51 +07:00
|
|
|
if (ret)
|
2011-02-07 11:27:04 +07:00
|
|
|
goto fail_unreserve;
|
2013-08-21 08:30:36 +07:00
|
|
|
} else {
|
|
|
|
struct nv04_display *dispnv04 = nv04_display(dev);
|
2013-11-11 10:59:40 +07: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 11:27:04 +07:00
|
|
|
}
|
|
|
|
|
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) {
|
2015-11-10 23:37:31 +07:00
|
|
|
if (drm->device.info.family < NV_DEVICE_INFO_V0_TESLA) {
|
2016-06-07 21:07:53 +07:00
|
|
|
drm_crtc_arm_vblank_event(s->crtc, s->event);
|
2015-11-10 23:37:31 +07:00
|
|
|
} else {
|
2016-06-07 21:07:53 +07:00
|
|
|
drm_crtc_send_vblank_event(s->crtc, s->event);
|
2014-05-13 05:42:08 +07:00
|
|
|
|
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);
|
2015-11-10 23:37:31 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* 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)) {
|
2014-08-10 01:10:22 +07:00
|
|
|
if (drm->device.info.family < NV_DEVICE_INFO_V0_TESLA) {
|
2016-06-07 21:07:53 +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)
|
|
|
|
{
|
|
|
|
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 */
|
|
|
|
if (nouveau_drm(dev)->device.info.ram_size != 0)
|
|
|
|
domain = NOUVEAU_GEM_DOMAIN_VRAM;
|
|
|
|
else
|
|
|
|
domain = NOUVEAU_GEM_DOMAIN_GART;
|
|
|
|
|
|
|
|
ret = nouveau_gem_new(dev, 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;
|
|
|
|
}
|