Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 71f4e45a authored by Dave Airlie's avatar Dave Airlie
Browse files

Merge branch 'linux-5.1' of git://github.com/skeggsb/linux into drm-next 



Various fixes/cleanups, along with initial support for SVM features
utilising HMM address-space mirroring and device memory migration.
There's a lot more work to do in these areas, both in terms of
features and efficiency, but these can slowly trickle in later down
the track.

Signed-off-by: default avatarDave Airlie <airlied@redhat.com>
From: Ben Skeggs <skeggsb@gmail.com>
Link: https://patchwork.freedesktop.org/patch/msgid/CACAvsv5bsB4rRY1Gqa_Bp_KAd-v_q1rGZ4nYmOAQhceL0Nr-Xg@mail.gmail.com
parents c06de561 a788ade4

drivers/gpu/drm/nouveau/Kbuild

+2 −0
Original line number Diff line number Diff line
@@ -30,6 +30,8 @@ nouveau-y += nouveau_vga.o 
# DRM - memory management

nouveau-y += nouveau_bo.o

nouveau-y += nouveau_gem.o

nouveau-$(CONFIG_DRM_NOUVEAU_SVM) += nouveau_svm.o

nouveau-$(CONFIG_DRM_NOUVEAU_SVM) += nouveau_dmem.o

nouveau-y += nouveau_mem.o

nouveau-y += nouveau_prime.o

nouveau-y += nouveau_sgdma.o

drivers/gpu/drm/nouveau/Kconfig

+12 −0
Original line number Diff line number Diff line
@@ -71,3 +71,15 @@ config DRM_NOUVEAU_BACKLIGHT 
	help

	  Say Y here if you want to control the backlight of your display

	  (e.g. a laptop panel).



config DRM_NOUVEAU_SVM

	bool "(EXPERIMENTAL) Enable SVM (Shared Virtual Memory) support"

	depends on ARCH_HAS_HMM

	depends on DRM_NOUVEAU

	depends on STAGING

	select HMM_MIRROR

	select DEVICE_PRIVATE

	default n

	help

	  Say Y here if you want to enable experimental support for

	  Shared Virtual Memory (SVM).

drivers/gpu/drm/nouveau/dispnv04/crtc.c

+213 −1
Original line number Diff line number Diff line
@@ -40,6 +40,7 @@ 
#include "nvreg.h"

#include "nouveau_fbcon.h"

#include "disp.h"

#include "nouveau_dma.h"



#include <subdev/bios/pll.h>

#include <subdev/clk.h>
@@ -1077,12 +1078,223 @@ nouveau_crtc_set_config(struct drm_mode_set *set, 
	return ret;

}



struct nv04_page_flip_state {

	struct list_head head;

	struct drm_pending_vblank_event *event;

	struct drm_crtc *crtc;

	int bpp, pitch;

	u64 offset;

};



static int

nv04_finish_page_flip(struct nouveau_channel *chan,

		      struct nv04_page_flip_state *ps)

{

	struct nouveau_fence_chan *fctx = chan->fence;

	struct nouveau_drm *drm = chan->drm;

	struct drm_device *dev = drm->dev;

	struct nv04_page_flip_state *s;

	unsigned long flags;



	spin_lock_irqsave(&dev->event_lock, flags);



	if (list_empty(&fctx->flip)) {

		NV_ERROR(drm, "unexpected pageflip\n");

		spin_unlock_irqrestore(&dev->event_lock, flags);

		return -EINVAL;

	}



	s = list_first_entry(&fctx->flip, struct nv04_page_flip_state, head);

	if (s->event) {

		drm_crtc_arm_vblank_event(s->crtc, s->event);

	} else {

		/* Give up ownership of vblank for page-flipped crtc */

		drm_crtc_vblank_put(s->crtc);

	}



	list_del(&s->head);

	if (ps)

		*ps = *s;

	kfree(s);



	spin_unlock_irqrestore(&dev->event_lock, flags);

	return 0;

}



int

nv04_flip_complete(struct nvif_notify *notify)

{

	struct nouveau_cli *cli = (void *)notify->object->client;

	struct nouveau_drm *drm = cli->drm;

	struct nouveau_channel *chan = drm->channel;

	struct nv04_page_flip_state state;



	if (!nv04_finish_page_flip(chan, &state)) {

		nv_set_crtc_base(drm->dev, drm_crtc_index(state.crtc),

				 state.offset + state.crtc->y *

				 state.pitch + state.crtc->x *

				 state.bpp / 8);

	}



	return NVIF_NOTIFY_KEEP;

}



static int

nv04_page_flip_emit(struct nouveau_channel *chan,

		    struct nouveau_bo *old_bo,

		    struct nouveau_bo *new_bo,

		    struct nv04_page_flip_state *s,

		    struct nouveau_fence **pfence)

{

	struct nouveau_fence_chan *fctx = chan->fence;

	struct nouveau_drm *drm = chan->drm;

	struct drm_device *dev = drm->dev;

	unsigned long flags;

	int ret;



	/* Queue it to the pending list */

	spin_lock_irqsave(&dev->event_lock, flags);

	list_add_tail(&s->head, &fctx->flip);

	spin_unlock_irqrestore(&dev->event_lock, flags);



	/* Synchronize with the old framebuffer */

	ret = nouveau_fence_sync(old_bo, chan, false, false);

	if (ret)

		goto fail;



	/* Emit the pageflip */

	ret = RING_SPACE(chan, 2);

	if (ret)

		goto fail;



	BEGIN_NV04(chan, NvSubSw, NV_SW_PAGE_FLIP, 1);

	OUT_RING  (chan, 0x00000000);

	FIRE_RING (chan);



	ret = nouveau_fence_new(chan, false, pfence);

	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;

}



static int

nv04_crtc_page_flip(struct drm_crtc *crtc, struct drm_framebuffer *fb,

		    struct drm_pending_vblank_event *event, u32 flags,

		    struct drm_modeset_acquire_ctx *ctx)

{

	const int swap_interval = (flags & DRM_MODE_PAGE_FLIP_ASYNC) ? 0 : 1;

	struct drm_device *dev = crtc->dev;

	struct nouveau_drm *drm = nouveau_drm(dev);

	struct nouveau_bo *old_bo = nouveau_framebuffer(crtc->primary->fb)->nvbo;

	struct nouveau_bo *new_bo = nouveau_framebuffer(fb)->nvbo;

	struct nv04_page_flip_state *s;

	struct nouveau_channel *chan;

	struct nouveau_cli *cli;

	struct nouveau_fence *fence;

	struct nv04_display *dispnv04 = nv04_display(dev);

	int head = nouveau_crtc(crtc)->index;

	int ret;



	chan = drm->channel;

	if (!chan)

		return -ENODEV;

	cli = (void *)chan->user.client;



	s = kzalloc(sizeof(*s), GFP_KERNEL);

	if (!s)

		return -ENOMEM;



	if (new_bo != old_bo) {

		ret = nouveau_bo_pin(new_bo, TTM_PL_FLAG_VRAM, true);

		if (ret)

			goto fail_free;

	}



	mutex_lock(&cli->mutex);

	ret = ttm_bo_reserve(&new_bo->bo, true, false, NULL);

	if (ret)

		goto fail_unpin;



	/* synchronise rendering channel with the kernel's channel */

	ret = nouveau_fence_sync(new_bo, chan, false, true);

	if (ret) {

		ttm_bo_unreserve(&new_bo->bo);

		goto fail_unpin;

	}



	if (new_bo != old_bo) {

		ttm_bo_unreserve(&new_bo->bo);



		ret = ttm_bo_reserve(&old_bo->bo, true, false, NULL);

		if (ret)

			goto fail_unpin;

	}



	/* Initialize a page flip struct */

	*s = (struct nv04_page_flip_state)

		{ { }, event, crtc, fb->format->cpp[0] * 8, fb->pitches[0],

		  new_bo->bo.offset };



	/* Keep vblanks on during flip, for the target crtc of this flip */

	drm_crtc_vblank_get(crtc);



	/* Emit a page flip */

	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]);



	ret = nv04_page_flip_emit(chan, old_bo, new_bo, s, &fence);

	if (ret)

		goto fail_unreserve;

	mutex_unlock(&cli->mutex);



	/* Update the crtc struct and cleanup */

	crtc->primary->fb = fb;



	nouveau_bo_fence(old_bo, fence, false);

	ttm_bo_unreserve(&old_bo->bo);

	if (old_bo != new_bo)

		nouveau_bo_unpin(old_bo);

	nouveau_fence_unref(&fence);

	return 0;



fail_unreserve:

	drm_crtc_vblank_put(crtc);

	ttm_bo_unreserve(&old_bo->bo);

fail_unpin:

	mutex_unlock(&cli->mutex);

	if (old_bo != new_bo)

		nouveau_bo_unpin(new_bo);

fail_free:

	kfree(s);

	return ret;

}



static const struct drm_crtc_funcs nv04_crtc_funcs = {

	.cursor_set = nv04_crtc_cursor_set,

	.cursor_move = nv04_crtc_cursor_move,

	.gamma_set = nv_crtc_gamma_set,

	.set_config = nouveau_crtc_set_config,

	.page_flip = nouveau_crtc_page_flip,

	.page_flip = nv04_crtc_page_flip,

	.destroy = nv_crtc_destroy,

};

drivers/gpu/drm/nouveau/dispnv04/disp.c

+161 −55
Original line number Diff line number Diff line
@@ -30,6 +30,160 @@ 
#include "hw.h"

#include "nouveau_encoder.h"

#include "nouveau_connector.h"

#include "nouveau_bo.h"



#include <nvif/if0004.h>



static void

nv04_display_fini(struct drm_device *dev, bool suspend)

{

	struct nv04_display *disp = nv04_display(dev);

	struct drm_crtc *crtc;



	/* Disable flip completion events. */

	nvif_notify_put(&disp->flip);



	/* Disable vblank interrupts. */

	NVWriteCRTC(dev, 0, NV_PCRTC_INTR_EN_0, 0);

	if (nv_two_heads(dev))

		NVWriteCRTC(dev, 1, NV_PCRTC_INTR_EN_0, 0);



	if (!suspend)

		return;



	/* Un-pin FB and cursors so they'll be evicted to system memory. */

	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {

		struct nouveau_framebuffer *nouveau_fb;



		nouveau_fb = nouveau_framebuffer(crtc->primary->fb);

		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);

		if (nv_crtc->cursor.nvbo) {

			if (nv_crtc->cursor.set_offset)

				nouveau_bo_unmap(nv_crtc->cursor.nvbo);

			nouveau_bo_unpin(nv_crtc->cursor.nvbo);

		}

	}

}



static int

nv04_display_init(struct drm_device *dev, bool resume, bool runtime)

{

	struct nv04_display *disp = nv04_display(dev);

	struct nouveau_drm *drm = nouveau_drm(dev);

	struct nouveau_encoder *encoder;

	struct drm_crtc *crtc;

	int ret;



	/* meh.. modeset apparently doesn't setup all the regs and depends

	 * on pre-existing state, for now load the state of the card *before*

	 * nouveau was loaded, and then do a modeset.

	 *

	 * best thing to do probably is to make save/restore routines not

	 * save/restore "pre-load" state, but more general so we can save

	 * on suspend too.

	 */

	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {

		struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);

		nv_crtc->save(&nv_crtc->base);

	}



	list_for_each_entry(encoder, &dev->mode_config.encoder_list, base.base.head)

		encoder->enc_save(&encoder->base.base);



	/* Enable flip completion events. */

	nvif_notify_get(&disp->flip);



	if (!resume)

		return 0;



	/* Re-pin FB/cursors. */

	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {

		struct nouveau_framebuffer *nouveau_fb;



		nouveau_fb = nouveau_framebuffer(crtc->primary->fb);

		if (!nouveau_fb || !nouveau_fb->nvbo)

			continue;



		ret = nouveau_bo_pin(nouveau_fb->nvbo, TTM_PL_FLAG_VRAM, true);

		if (ret)

			NV_ERROR(drm, "Could not pin framebuffer\n");

	}



	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {

		struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);

		if (!nv_crtc->cursor.nvbo)

			continue;



		ret = nouveau_bo_pin(nv_crtc->cursor.nvbo, TTM_PL_FLAG_VRAM, true);

		if (!ret && nv_crtc->cursor.set_offset)

			ret = nouveau_bo_map(nv_crtc->cursor.nvbo);

		if (ret)

			NV_ERROR(drm, "Could not pin/map cursor.\n");

	}



	/* 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;

	}



	/* 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 0;



	/* Restore mode. */

	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);



		if (!nv_crtc->cursor.nvbo)

			continue;



		if (nv_crtc->cursor.set_offset)

			nv_crtc->cursor.set_offset(nv_crtc, nv_crtc->cursor.nvbo->bo.offset);

		nv_crtc->cursor.set_pos(nv_crtc, nv_crtc->cursor_saved_x,

						 nv_crtc->cursor_saved_y);

	}



	return 0;

}



static void

nv04_display_destroy(struct drm_device *dev)

{

	struct nv04_display *disp = nv04_display(dev);

	struct nouveau_drm *drm = nouveau_drm(dev);

	struct nouveau_encoder *encoder;

	struct nouveau_crtc *nv_crtc;



	/* Restore state */

	list_for_each_entry(encoder, &dev->mode_config.encoder_list, base.base.head)

		encoder->enc_restore(&encoder->base.base);



	list_for_each_entry(nv_crtc, &dev->mode_config.crtc_list, base.head)

		nv_crtc->restore(&nv_crtc->base);



	nouveau_hw_save_vga_fonts(dev, 0);



	nvif_notify_fini(&disp->flip);



	nouveau_display(dev)->priv = NULL;

	kfree(disp);



	nvif_object_unmap(&drm->client.device.object);

}



int

nv04_display_create(struct drm_device *dev)
@@ -58,6 +212,13 @@ nv04_display_create(struct drm_device *dev) 
	/* Pre-nv50 doesn't support atomic, so don't expose the ioctls */

	dev->driver->driver_features &= ~DRIVER_ATOMIC;



	/* Request page flip completion event. */

	if (drm->nvsw.client) {

		nvif_notify_init(&drm->nvsw, nv04_flip_complete,

				 false, NV04_NVSW_NTFY_UEVENT,

				 NULL, 0, 0, &disp->flip);

	}



	nouveau_hw_save_vga_fonts(dev, 1);



	nv04_crtc_create(dev, 0);
@@ -121,58 +282,3 @@ nv04_display_create(struct drm_device *dev) 


	return 0;

}
 


void

nv04_display_destroy(struct drm_device *dev)

{

	struct nv04_display *disp = nv04_display(dev);

	struct nouveau_drm *drm = nouveau_drm(dev);

	struct nouveau_encoder *encoder;

	struct nouveau_crtc *nv_crtc;



	/* Restore state */

	list_for_each_entry(encoder, &dev->mode_config.encoder_list, base.base.head)

		encoder->enc_restore(&encoder->base.base);



	list_for_each_entry(nv_crtc, &dev->mode_config.crtc_list, base.head)

		nv_crtc->restore(&nv_crtc->base);



	nouveau_hw_save_vga_fonts(dev, 0);



	nouveau_display(dev)->priv = NULL;

	kfree(disp);



	nvif_object_unmap(&drm->client.device.object);

}



int

nv04_display_init(struct drm_device *dev)

{

	struct nouveau_encoder *encoder;

	struct nouveau_crtc *crtc;



	/* meh.. modeset apparently doesn't setup all the regs and depends

	 * on pre-existing state, for now load the state of the card *before*

	 * nouveau was loaded, and then do a modeset.

	 *

	 * best thing to do probably is to make save/restore routines not

	 * save/restore "pre-load" state, but more general so we can save

	 * on suspend too.

	 */

	list_for_each_entry(crtc, &dev->mode_config.crtc_list, base.head)

		crtc->save(&crtc->base);



	list_for_each_entry(encoder, &dev->mode_config.encoder_list, base.base.head)

		encoder->enc_save(&encoder->base.base);



	return 0;

}



void

nv04_display_fini(struct drm_device *dev)

{

	/* disable vblank interrupts */

	NVWriteCRTC(dev, 0, NV_PCRTC_INTR_EN_0, 0);

	if (nv_two_heads(dev))

		NVWriteCRTC(dev, 1, NV_PCRTC_INTR_EN_0, 0);

}

drivers/gpu/drm/nouveau/dispnv04/disp.h

+2 −3
Original line number Diff line number Diff line
@@ -82,6 +82,7 @@ struct nv04_display { 
	uint32_t saved_vga_font[4][16384];

	uint32_t dac_users[4];

	struct nouveau_bo *image[2];

	struct nvif_notify flip;

};



static inline struct nv04_display *
@@ -92,9 +93,6 @@ nv04_display(struct drm_device *dev) 


/* nv04_display.c */

int nv04_display_create(struct drm_device *);

void nv04_display_destroy(struct drm_device *);

int nv04_display_init(struct drm_device *);

void nv04_display_fini(struct drm_device *);



/* nv04_crtc.c */

int nv04_crtc_create(struct drm_device *, int index);
@@ -176,4 +174,5 @@ nouveau_bios_run_init_table(struct drm_device *dev, u16 table, 
	);

}



int nv04_flip_complete(struct nvif_notify *);

#endif