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

Commit 8c914028 authored by Dave Airlie's avatar Dave Airlie
Browse files

Merge branch 'drm-nouveau-next' of... 

Merge branch 'drm-nouveau-next' of git://anongit.freedesktop.org/git/nouveau/linux-2.6 into drm-core-next

Ben was distracted:

"Apologies for being really late with this, feel free to bash me in the
future so I remember on time!

Overview:
- improvements to reclocking (especially memory) on nva3+
- kepler accel support (if you have blob ucode)
- better inter-channel synchronisation on nv84+
- async ttm buffer moves on nv84+ (earlier cards don't have a non-PGRAPH
engine that's useful)"

* 'drm-nouveau-next' of git://anongit.freedesktop.org/git/nouveau/linux-2.6: (60 commits)
  drm/nouveau/nvd9: Fix GPIO initialisation sequence.
  drm/nouveau: Unregister switcheroo client on exit
  drm/nouveau: Check dsm on switcheroo unregister
  drm/nouveau: fix a minor annoyance in an output string
  drm/nouveau: turn a BUG into a WARN
  drm/nv50: decode PGRAPH DATA_ERROR = 0x24
  drm/nouveau/disp: fix dithering not being enabled on some eDP macbooks
  drm/nvd9/copy: initialise copy engine, seems to work like nvc0
  drm/nvc0/ttm: use copy engines for async buffer moves
  drm/nva3/ttm: use copy engine for async buffer moves
  drm/nv98/ttm: add in a (disabled) crypto engine buffer copy method
  drm/nv84/ttm: use crypto engine for async buffer copies
  drm/nouveau/ttm: untangle code to support accelerated buffer moves
  drm/nouveau/fbcon: use fence for sync, rather than notifier
  drm/nv98/crypt: non-stub implementation of the engine hooks
  drm/nouveau/fifo: turn all fifo modules into engine modules
  drm/nv50/graph: remove ability to do interrupt-driven context switching
  drm/nv50: remove manual context unload on context destruction
  drm/nv50: remove execution engine context saves on suspend
  drm/nv50/fifo: use hardware channel kickoff functionality
  ...
parents 41ceeeb2 af3289e9

drivers/gpu/drm/nouveau/Makefile

+6 −3
Original line number Diff line number Diff line
@@ -16,10 +16,13 @@ nouveau-y := nouveau_drv.o nouveau_state.o nouveau_channel.o nouveau_mem.o \ 
             nv04_mc.o nv40_mc.o nv50_mc.o \

             nv04_fb.o nv10_fb.o nv20_fb.o nv30_fb.o nv40_fb.o \

             nv50_fb.o nvc0_fb.o \

             nv04_fifo.o nv10_fifo.o nv40_fifo.o nv50_fifo.o nvc0_fifo.o \

             nv04_fifo.o nv10_fifo.o nv17_fifo.o nv40_fifo.o nv50_fifo.o \

             nv84_fifo.o nvc0_fifo.o nve0_fifo.o \

             nv04_fence.o nv10_fence.o nv84_fence.o nvc0_fence.o \

             nv04_software.o nv50_software.o nvc0_software.o \

             nv04_graph.o nv10_graph.o nv20_graph.o \

             nv40_graph.o nv50_graph.o nvc0_graph.o \

             nv40_grctx.o nv50_grctx.o nvc0_grctx.o \

             nv40_graph.o nv50_graph.o nvc0_graph.o nve0_graph.o \

             nv40_grctx.o nv50_grctx.o nvc0_grctx.o nve0_grctx.o \

             nv84_crypt.o nv98_crypt.o \

             nva3_copy.o nvc0_copy.o \

             nv31_mpeg.o nv50_mpeg.o \

drivers/gpu/drm/nouveau/nouveau_acpi.c

+2 −1
Original line number Diff line number Diff line
@@ -338,6 +338,7 @@ void nouveau_switcheroo_optimus_dsm(void) 


void nouveau_unregister_dsm_handler(void)

{

	if (nouveau_dsm_priv.optimus_detected || nouveau_dsm_priv.dsm_detected)

		vga_switcheroo_unregister_handler();

}

drivers/gpu/drm/nouveau/nouveau_bios.c

+31 −20
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ 
#include "nouveau_gpio.h"



#include <linux/io-mapping.h>

#include <linux/firmware.h>



/* these defines are made up */

#define NV_CIO_CRE_44_HEADA 0x0
@@ -195,35 +196,24 @@ static void 
bios_shadow_acpi(struct nvbios *bios)

{

	struct pci_dev *pdev = bios->dev->pdev;

	int ptr, len, ret;

	u8 data[3];

	int cnt = 65536 / ROM_BIOS_PAGE;

	int ret;



	if (!nouveau_acpi_rom_supported(pdev))

		return;



	ret = nouveau_acpi_get_bios_chunk(data, 0, sizeof(data));

	if (ret != sizeof(data))

		return;



	bios->length = min(data[2] * 512, 65536);

	bios->data = kmalloc(bios->length, GFP_KERNEL);

	bios->data = kmalloc(cnt * ROM_BIOS_PAGE, GFP_KERNEL);

	if (!bios->data)

		return;



	len = bios->length;

	ptr = 0;

	while (len) {

		int size = (len > ROM_BIOS_PAGE) ? ROM_BIOS_PAGE : len;



		ret = nouveau_acpi_get_bios_chunk(bios->data, ptr, size);

		if (ret != size) {

			kfree(bios->data);

			bios->data = NULL;

	bios->length = 0;

	while (cnt--) {

		ret = nouveau_acpi_get_bios_chunk(bios->data, bios->length,

						  ROM_BIOS_PAGE);

		if (ret != ROM_BIOS_PAGE)

			return;

		}



		len -= size;

		ptr += size;

		bios->length += ROM_BIOS_PAGE;

	}

}
@@ -249,8 +239,12 @@ bios_shadow(struct drm_device *dev) 
	struct drm_nouveau_private *dev_priv = dev->dev_private;

	struct nvbios *bios = &dev_priv->vbios;

	struct methods *mthd, *best;

	const struct firmware *fw;

	char fname[32];

	int ret;



	if (nouveau_vbios) {

		/* try to match one of the built-in methods */

		mthd = shadow_methods;

		do {

			if (strcasecmp(nouveau_vbios, mthd->desc))
@@ -263,6 +257,22 @@ bios_shadow(struct drm_device *dev) 
				return true;

		} while ((++mthd)->shadow);



		/* attempt to load firmware image */

		snprintf(fname, sizeof(fname), "nouveau/%s", nouveau_vbios);

		ret = request_firmware(&fw, fname, &dev->pdev->dev);

		if (ret == 0) {

			bios->length = fw->size;

			bios->data   = kmemdup(fw->data, fw->size, GFP_KERNEL);

			release_firmware(fw);



			NV_INFO(dev, "VBIOS image: %s\n", nouveau_vbios);

			if (score_vbios(bios, 1))

				return true;



			kfree(bios->data);

			bios->data = NULL;

		}



		NV_ERROR(dev, "VBIOS source \'%s\' invalid\n", nouveau_vbios);

	}
@@ -273,6 +283,7 @@ bios_shadow(struct drm_device *dev) 
		mthd->score = score_vbios(bios, mthd->rw);

		mthd->size = bios->length;

		mthd->data = bios->data;

		bios->data = NULL;

	} while (mthd->score != 3 && (++mthd)->shadow);



	mthd = shadow_methods;

drivers/gpu/drm/nouveau/nouveau_bo.c

+297 −44
Original line number Diff line number Diff line
@@ -35,6 +35,8 @@ 
#include "nouveau_dma.h"

#include "nouveau_mm.h"

#include "nouveau_vm.h"

#include "nouveau_fence.h"

#include "nouveau_ramht.h"



#include <linux/log2.h>

#include <linux/slab.h>
@@ -478,7 +480,7 @@ nouveau_bo_move_accel_cleanup(struct nouveau_channel *chan, 
	struct nouveau_fence *fence = NULL;

	int ret;



	ret = nouveau_fence_new(chan, &fence, true);

	ret = nouveau_fence_new(chan, &fence);

	if (ret)

		return ret;
@@ -488,6 +490,76 @@ nouveau_bo_move_accel_cleanup(struct nouveau_channel *chan, 
	return ret;

}



static int

nve0_bo_move_copy(struct nouveau_channel *chan, struct ttm_buffer_object *bo,

		  struct ttm_mem_reg *old_mem, struct ttm_mem_reg *new_mem)

{

	struct nouveau_mem *node = old_mem->mm_node;

	int ret = RING_SPACE(chan, 10);

	if (ret == 0) {

		BEGIN_NVC0(chan, NvSubCopy, 0x0400, 8);

		OUT_RING  (chan, upper_32_bits(node->vma[0].offset));

		OUT_RING  (chan, lower_32_bits(node->vma[0].offset));

		OUT_RING  (chan, upper_32_bits(node->vma[1].offset));

		OUT_RING  (chan, lower_32_bits(node->vma[1].offset));

		OUT_RING  (chan, PAGE_SIZE);

		OUT_RING  (chan, PAGE_SIZE);

		OUT_RING  (chan, PAGE_SIZE);

		OUT_RING  (chan, new_mem->num_pages);

		BEGIN_IMC0(chan, NvSubCopy, 0x0300, 0x0386);

	}

	return ret;

}



static int

nvc0_bo_move_init(struct nouveau_channel *chan, u32 handle)

{

	int ret = RING_SPACE(chan, 2);

	if (ret == 0) {

		BEGIN_NVC0(chan, NvSubCopy, 0x0000, 1);

		OUT_RING  (chan, handle);

	}

	return ret;

}



static int

nvc0_bo_move_copy(struct nouveau_channel *chan, struct ttm_buffer_object *bo,

		  struct ttm_mem_reg *old_mem, struct ttm_mem_reg *new_mem)

{

	struct nouveau_mem *node = old_mem->mm_node;

	u64 src_offset = node->vma[0].offset;

	u64 dst_offset = node->vma[1].offset;

	u32 page_count = new_mem->num_pages;

	int ret;



	page_count = new_mem->num_pages;

	while (page_count) {

		int line_count = (page_count > 8191) ? 8191 : page_count;



		ret = RING_SPACE(chan, 11);

		if (ret)

			return ret;



		BEGIN_NVC0(chan, NvSubCopy, 0x030c, 8);

		OUT_RING  (chan, upper_32_bits(src_offset));

		OUT_RING  (chan, lower_32_bits(src_offset));

		OUT_RING  (chan, upper_32_bits(dst_offset));

		OUT_RING  (chan, lower_32_bits(dst_offset));

		OUT_RING  (chan, PAGE_SIZE);

		OUT_RING  (chan, PAGE_SIZE);

		OUT_RING  (chan, PAGE_SIZE);

		OUT_RING  (chan, line_count);

		BEGIN_NVC0(chan, NvSubCopy, 0x0300, 1);

		OUT_RING  (chan, 0x00000110);



		page_count -= line_count;

		src_offset += (PAGE_SIZE * line_count);

		dst_offset += (PAGE_SIZE * line_count);

	}



	return 0;

}



static int

nvc0_bo_move_m2mf(struct nouveau_channel *chan, struct ttm_buffer_object *bo,

		  struct ttm_mem_reg *old_mem, struct ttm_mem_reg *new_mem)
@@ -506,17 +578,17 @@ nvc0_bo_move_m2mf(struct nouveau_channel *chan, struct ttm_buffer_object *bo, 
		if (ret)

			return ret;



		BEGIN_NVC0(chan, 2, NvSubM2MF, 0x0238, 2);

		BEGIN_NVC0(chan, NvSubCopy, 0x0238, 2);

		OUT_RING  (chan, upper_32_bits(dst_offset));

		OUT_RING  (chan, lower_32_bits(dst_offset));

		BEGIN_NVC0(chan, 2, NvSubM2MF, 0x030c, 6);

		BEGIN_NVC0(chan, NvSubCopy, 0x030c, 6);

		OUT_RING  (chan, upper_32_bits(src_offset));

		OUT_RING  (chan, lower_32_bits(src_offset));

		OUT_RING  (chan, PAGE_SIZE); /* src_pitch */

		OUT_RING  (chan, PAGE_SIZE); /* dst_pitch */

		OUT_RING  (chan, PAGE_SIZE); /* line_length */

		OUT_RING  (chan, line_count);

		BEGIN_NVC0(chan, 2, NvSubM2MF, 0x0300, 1);

		BEGIN_NVC0(chan, NvSubCopy, 0x0300, 1);

		OUT_RING  (chan, 0x00100110);



		page_count -= line_count;
@@ -527,6 +599,102 @@ nvc0_bo_move_m2mf(struct nouveau_channel *chan, struct ttm_buffer_object *bo, 
	return 0;

}



static int

nva3_bo_move_copy(struct nouveau_channel *chan, struct ttm_buffer_object *bo,

		  struct ttm_mem_reg *old_mem, struct ttm_mem_reg *new_mem)

{

	struct nouveau_mem *node = old_mem->mm_node;

	u64 src_offset = node->vma[0].offset;

	u64 dst_offset = node->vma[1].offset;

	u32 page_count = new_mem->num_pages;

	int ret;



	page_count = new_mem->num_pages;

	while (page_count) {

		int line_count = (page_count > 8191) ? 8191 : page_count;



		ret = RING_SPACE(chan, 11);

		if (ret)

			return ret;



		BEGIN_NV04(chan, NvSubCopy, 0x030c, 8);

		OUT_RING  (chan, upper_32_bits(src_offset));

		OUT_RING  (chan, lower_32_bits(src_offset));

		OUT_RING  (chan, upper_32_bits(dst_offset));

		OUT_RING  (chan, lower_32_bits(dst_offset));

		OUT_RING  (chan, PAGE_SIZE);

		OUT_RING  (chan, PAGE_SIZE);

		OUT_RING  (chan, PAGE_SIZE);

		OUT_RING  (chan, line_count);

		BEGIN_NV04(chan, NvSubCopy, 0x0300, 1);

		OUT_RING  (chan, 0x00000110);



		page_count -= line_count;

		src_offset += (PAGE_SIZE * line_count);

		dst_offset += (PAGE_SIZE * line_count);

	}



	return 0;

}



static int

nv98_bo_move_exec(struct nouveau_channel *chan, struct ttm_buffer_object *bo,

		  struct ttm_mem_reg *old_mem, struct ttm_mem_reg *new_mem)

{

	struct nouveau_mem *node = old_mem->mm_node;

	int ret = RING_SPACE(chan, 7);

	if (ret == 0) {

		BEGIN_NV04(chan, NvSubCopy, 0x0320, 6);

		OUT_RING  (chan, upper_32_bits(node->vma[0].offset));

		OUT_RING  (chan, lower_32_bits(node->vma[0].offset));

		OUT_RING  (chan, upper_32_bits(node->vma[1].offset));

		OUT_RING  (chan, lower_32_bits(node->vma[1].offset));

		OUT_RING  (chan, 0x00000000 /* COPY */);

		OUT_RING  (chan, new_mem->num_pages << PAGE_SHIFT);

	}

	return ret;

}



static int

nv84_bo_move_exec(struct nouveau_channel *chan, struct ttm_buffer_object *bo,

		  struct ttm_mem_reg *old_mem, struct ttm_mem_reg *new_mem)

{

	struct nouveau_mem *node = old_mem->mm_node;

	int ret = RING_SPACE(chan, 7);

	if (ret == 0) {

		BEGIN_NV04(chan, NvSubCopy, 0x0304, 6);

		OUT_RING  (chan, new_mem->num_pages << PAGE_SHIFT);

		OUT_RING  (chan, upper_32_bits(node->vma[0].offset));

		OUT_RING  (chan, lower_32_bits(node->vma[0].offset));

		OUT_RING  (chan, upper_32_bits(node->vma[1].offset));

		OUT_RING  (chan, lower_32_bits(node->vma[1].offset));

		OUT_RING  (chan, 0x00000000 /* MODE_COPY, QUERY_NONE */);

	}

	return ret;

}



static int

nv50_bo_move_init(struct nouveau_channel *chan, u32 handle)

{

	int ret = nouveau_notifier_alloc(chan, NvNotify0, 32, 0xfe0, 0x1000,

					 &chan->m2mf_ntfy);

	if (ret == 0) {

		ret = RING_SPACE(chan, 6);

		if (ret == 0) {

			BEGIN_NV04(chan, NvSubCopy, 0x0000, 1);

			OUT_RING  (chan, handle);

			BEGIN_NV04(chan, NvSubCopy, 0x0180, 3);

			OUT_RING  (chan, NvNotify0);

			OUT_RING  (chan, NvDmaFB);

			OUT_RING  (chan, NvDmaFB);

		} else {

			nouveau_ramht_remove(chan, NvNotify0);

		}

	}



	return ret;

}



static int

nv50_bo_move_m2mf(struct nouveau_channel *chan, struct ttm_buffer_object *bo,

		  struct ttm_mem_reg *old_mem, struct ttm_mem_reg *new_mem)
@@ -551,7 +719,7 @@ nv50_bo_move_m2mf(struct nouveau_channel *chan, struct ttm_buffer_object *bo, 
			if (ret)

				return ret;



			BEGIN_RING(chan, NvSubM2MF, 0x0200, 7);

			BEGIN_NV04(chan, NvSubCopy, 0x0200, 7);

			OUT_RING  (chan, 0);

			OUT_RING  (chan, 0);

			OUT_RING  (chan, stride);
@@ -564,7 +732,7 @@ nv50_bo_move_m2mf(struct nouveau_channel *chan, struct ttm_buffer_object *bo, 
			if (ret)

				return ret;



			BEGIN_RING(chan, NvSubM2MF, 0x0200, 1);

			BEGIN_NV04(chan, NvSubCopy, 0x0200, 1);

			OUT_RING  (chan, 1);

		}

		if (old_mem->mem_type == TTM_PL_VRAM &&
@@ -573,7 +741,7 @@ nv50_bo_move_m2mf(struct nouveau_channel *chan, struct ttm_buffer_object *bo, 
			if (ret)

				return ret;



			BEGIN_RING(chan, NvSubM2MF, 0x021c, 7);

			BEGIN_NV04(chan, NvSubCopy, 0x021c, 7);

			OUT_RING  (chan, 0);

			OUT_RING  (chan, 0);

			OUT_RING  (chan, stride);
@@ -586,7 +754,7 @@ nv50_bo_move_m2mf(struct nouveau_channel *chan, struct ttm_buffer_object *bo, 
			if (ret)

				return ret;



			BEGIN_RING(chan, NvSubM2MF, 0x021c, 1);

			BEGIN_NV04(chan, NvSubCopy, 0x021c, 1);

			OUT_RING  (chan, 1);

		}
@@ -594,10 +762,10 @@ nv50_bo_move_m2mf(struct nouveau_channel *chan, struct ttm_buffer_object *bo, 
		if (ret)

			return ret;



		BEGIN_RING(chan, NvSubM2MF, 0x0238, 2);

		BEGIN_NV04(chan, NvSubCopy, 0x0238, 2);

		OUT_RING  (chan, upper_32_bits(src_offset));

		OUT_RING  (chan, upper_32_bits(dst_offset));

		BEGIN_RING(chan, NvSubM2MF, 0x030c, 8);

		BEGIN_NV04(chan, NvSubCopy, 0x030c, 8);

		OUT_RING  (chan, lower_32_bits(src_offset));

		OUT_RING  (chan, lower_32_bits(dst_offset));

		OUT_RING  (chan, stride);
@@ -606,7 +774,7 @@ nv50_bo_move_m2mf(struct nouveau_channel *chan, struct ttm_buffer_object *bo, 
		OUT_RING  (chan, height);

		OUT_RING  (chan, 0x00000101);

		OUT_RING  (chan, 0x00000000);

		BEGIN_RING(chan, NvSubM2MF, NV_MEMORY_TO_MEMORY_FORMAT_NOP, 1);

		BEGIN_NV04(chan, NvSubCopy, NV_MEMORY_TO_MEMORY_FORMAT_NOP, 1);

		OUT_RING  (chan, 0);



		length -= amount;
@@ -617,6 +785,24 @@ nv50_bo_move_m2mf(struct nouveau_channel *chan, struct ttm_buffer_object *bo, 
	return 0;

}



static int

nv04_bo_move_init(struct nouveau_channel *chan, u32 handle)

{

	int ret = nouveau_notifier_alloc(chan, NvNotify0, 32, 0xfe0, 0x1000,

					 &chan->m2mf_ntfy);

	if (ret == 0) {

		ret = RING_SPACE(chan, 4);

		if (ret == 0) {

			BEGIN_NV04(chan, NvSubCopy, 0x0000, 1);

			OUT_RING  (chan, handle);

			BEGIN_NV04(chan, NvSubCopy, 0x0180, 1);

			OUT_RING  (chan, NvNotify0);

		}

	}



	return ret;

}



static inline uint32_t

nouveau_bo_mem_ctxdma(struct ttm_buffer_object *bo,

		      struct nouveau_channel *chan, struct ttm_mem_reg *mem)
@@ -639,7 +825,7 @@ nv04_bo_move_m2mf(struct nouveau_channel *chan, struct ttm_buffer_object *bo, 
	if (ret)

		return ret;



	BEGIN_RING(chan, NvSubM2MF, NV_MEMORY_TO_MEMORY_FORMAT_DMA_SOURCE, 2);

	BEGIN_NV04(chan, NvSubCopy, NV_MEMORY_TO_MEMORY_FORMAT_DMA_SOURCE, 2);

	OUT_RING  (chan, nouveau_bo_mem_ctxdma(bo, chan, old_mem));

	OUT_RING  (chan, nouveau_bo_mem_ctxdma(bo, chan, new_mem));
@@ -651,7 +837,7 @@ nv04_bo_move_m2mf(struct nouveau_channel *chan, struct ttm_buffer_object *bo, 
		if (ret)

			return ret;



		BEGIN_RING(chan, NvSubM2MF,

		BEGIN_NV04(chan, NvSubCopy,

				 NV_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN, 8);

		OUT_RING  (chan, src_offset);

		OUT_RING  (chan, dst_offset);
@@ -661,7 +847,7 @@ nv04_bo_move_m2mf(struct nouveau_channel *chan, struct ttm_buffer_object *bo, 
		OUT_RING  (chan, line_count);

		OUT_RING  (chan, 0x00000101);

		OUT_RING  (chan, 0x00000000);

		BEGIN_RING(chan, NvSubM2MF, NV_MEMORY_TO_MEMORY_FORMAT_NOP, 1);

		BEGIN_NV04(chan, NvSubCopy, NV_MEMORY_TO_MEMORY_FORMAT_NOP, 1);

		OUT_RING  (chan, 0);



		page_count -= line_count;
@@ -721,13 +907,7 @@ nouveau_bo_move_m2mf(struct ttm_buffer_object *bo, int evict, bool intr, 
			goto out;

	}



	if (dev_priv->card_type < NV_50)

		ret = nv04_bo_move_m2mf(chan, bo, &bo->mem, new_mem);

	else

	if (dev_priv->card_type < NV_C0)

		ret = nv50_bo_move_m2mf(chan, bo, &bo->mem, new_mem);

	else

		ret = nvc0_bo_move_m2mf(chan, bo, &bo->mem, new_mem);

	ret = dev_priv->ttm.move(chan, bo, &bo->mem, new_mem);

	if (ret == 0) {

		ret = nouveau_bo_move_accel_cleanup(chan, nvbo, evict,

						    no_wait_reserve,
@@ -739,6 +919,49 @@ nouveau_bo_move_m2mf(struct ttm_buffer_object *bo, int evict, bool intr, 
	return ret;

}



void

nouveau_bo_move_init(struct nouveau_channel *chan)

{

	struct drm_nouveau_private *dev_priv = chan->dev->dev_private;

	static const struct {

		const char *name;

		int engine;

		u32 oclass;

		int (*exec)(struct nouveau_channel *,

			    struct ttm_buffer_object *,

			    struct ttm_mem_reg *, struct ttm_mem_reg *);

		int (*init)(struct nouveau_channel *, u32 handle);

	} _methods[] = {

		{  "COPY", 0, 0xa0b5, nve0_bo_move_copy, nvc0_bo_move_init },

		{ "COPY1", 5, 0x90b8, nvc0_bo_move_copy, nvc0_bo_move_init },

		{ "COPY0", 4, 0x90b5, nvc0_bo_move_copy, nvc0_bo_move_init },

		{  "COPY", 0, 0x85b5, nva3_bo_move_copy, nv50_bo_move_init },

		{ "CRYPT", 0, 0x74c1, nv84_bo_move_exec, nv50_bo_move_init },

		{  "M2MF", 0, 0x9039, nvc0_bo_move_m2mf, nvc0_bo_move_init },

		{  "M2MF", 0, 0x5039, nv50_bo_move_m2mf, nv50_bo_move_init },

		{  "M2MF", 0, 0x0039, nv04_bo_move_m2mf, nv04_bo_move_init },

		{},

		{ "CRYPT", 0, 0x88b4, nv98_bo_move_exec, nv50_bo_move_init },

	}, *mthd = _methods;

	const char *name = "CPU";

	int ret;



	do {

		u32 handle = (mthd->engine << 16) | mthd->oclass;

		ret = nouveau_gpuobj_gr_new(chan, handle, mthd->oclass);

		if (ret == 0) {

			ret = mthd->init(chan, handle);

			if (ret == 0) {

				dev_priv->ttm.move = mthd->exec;

				name = mthd->name;

				break;

			}

		}

	} while ((++mthd)->exec);



	NV_INFO(chan->dev, "MM: using %s for buffer copies\n", name);

}



static int

nouveau_bo_move_flipd(struct ttm_buffer_object *bo, bool evict, bool intr,

		      bool no_wait_reserve, bool no_wait_gpu,
@@ -895,8 +1118,8 @@ nouveau_bo_move(struct ttm_buffer_object *bo, bool evict, bool intr, 
		goto out;

	}



	/* Software copy if the card isn't up and running yet. */

	if (!dev_priv->channel) {

	/* CPU copy if we have no accelerated method available */

	if (!dev_priv->ttm.move) {

		ret = ttm_bo_move_memcpy(bo, evict, no_wait_reserve, no_wait_gpu, new_mem);

		goto out;

	}
@@ -1044,22 +1267,6 @@ nouveau_ttm_fault_reserve_notify(struct ttm_buffer_object *bo) 
	return nouveau_bo_validate(nvbo, false, true, false);

}



void

nouveau_bo_fence(struct nouveau_bo *nvbo, struct nouveau_fence *fence)

{

	struct nouveau_fence *old_fence;



	if (likely(fence))

		nouveau_fence_ref(fence);



	spin_lock(&nvbo->bo.bdev->fence_lock);

	old_fence = nvbo->bo.sync_obj;

	nvbo->bo.sync_obj = fence;

	spin_unlock(&nvbo->bo.bdev->fence_lock);



	nouveau_fence_unref(&old_fence);

}



static int

nouveau_ttm_tt_populate(struct ttm_tt *ttm)

{
@@ -1157,6 +1364,52 @@ nouveau_ttm_tt_unpopulate(struct ttm_tt *ttm) 
	ttm_pool_unpopulate(ttm);

}



void

nouveau_bo_fence(struct nouveau_bo *nvbo, struct nouveau_fence *fence)

{

	struct nouveau_fence *old_fence = NULL;



	if (likely(fence))

		nouveau_fence_ref(fence);



	spin_lock(&nvbo->bo.bdev->fence_lock);

	old_fence = nvbo->bo.sync_obj;

	nvbo->bo.sync_obj = fence;

	spin_unlock(&nvbo->bo.bdev->fence_lock);



	nouveau_fence_unref(&old_fence);

}



static void

nouveau_bo_fence_unref(void **sync_obj)

{

	nouveau_fence_unref((struct nouveau_fence **)sync_obj);

}



static void *

nouveau_bo_fence_ref(void *sync_obj)

{

	return nouveau_fence_ref(sync_obj);

}



static bool

nouveau_bo_fence_signalled(void *sync_obj, void *sync_arg)

{

	return nouveau_fence_done(sync_obj);

}



static int

nouveau_bo_fence_wait(void *sync_obj, void *sync_arg, bool lazy, bool intr)

{

	return nouveau_fence_wait(sync_obj, lazy, intr);

}



static int

nouveau_bo_fence_flush(void *sync_obj, void *sync_arg)

{

	return 0;

}



struct ttm_bo_driver nouveau_bo_driver = {

	.ttm_tt_create = &nouveau_ttm_tt_create,

	.ttm_tt_populate = &nouveau_ttm_tt_populate,
@@ -1167,11 +1420,11 @@ struct ttm_bo_driver nouveau_bo_driver = { 
	.move_notify = nouveau_bo_move_ntfy,

	.move = nouveau_bo_move,

	.verify_access = nouveau_bo_verify_access,

	.sync_obj_signaled = __nouveau_fence_signalled,

	.sync_obj_wait = __nouveau_fence_wait,

	.sync_obj_flush = __nouveau_fence_flush,

	.sync_obj_unref = __nouveau_fence_unref,

	.sync_obj_ref = __nouveau_fence_ref,

	.sync_obj_signaled = nouveau_bo_fence_signalled,

	.sync_obj_wait = nouveau_bo_fence_wait,

	.sync_obj_flush = nouveau_bo_fence_flush,

	.sync_obj_unref = nouveau_bo_fence_unref,

	.sync_obj_ref = nouveau_bo_fence_ref,

	.fault_reserve_notify = &nouveau_ttm_fault_reserve_notify,

	.io_mem_reserve = &nouveau_ttm_io_mem_reserve,

	.io_mem_free = &nouveau_ttm_io_mem_free,

drivers/gpu/drm/nouveau/nouveau_channel.c

+43 −43
Original line number Diff line number Diff line
@@ -27,7 +27,10 @@ 
#include "nouveau_drv.h"

#include "nouveau_drm.h"

#include "nouveau_dma.h"

#include "nouveau_fifo.h"

#include "nouveau_ramht.h"

#include "nouveau_fence.h"

#include "nouveau_software.h"



static int

nouveau_channel_pushbuf_init(struct nouveau_channel *chan)
@@ -117,8 +120,9 @@ nouveau_channel_alloc(struct drm_device *dev, struct nouveau_channel **chan_ret, 
		      struct drm_file *file_priv,

		      uint32_t vram_handle, uint32_t gart_handle)

{

	struct nouveau_exec_engine *fence = nv_engine(dev, NVOBJ_ENGINE_FENCE);

	struct nouveau_fifo_priv *pfifo = nv_engine(dev, NVOBJ_ENGINE_FIFO);

	struct drm_nouveau_private *dev_priv = dev->dev_private;

	struct nouveau_fifo_engine *pfifo = &dev_priv->engine.fifo;

	struct nouveau_fpriv *fpriv = nouveau_fpriv(file_priv);

	struct nouveau_channel *chan;

	unsigned long flags;
@@ -155,10 +159,6 @@ nouveau_channel_alloc(struct drm_device *dev, struct nouveau_channel **chan_ret, 
	}



	NV_DEBUG(dev, "initialising channel %d\n", chan->id);

	INIT_LIST_HEAD(&chan->nvsw.vbl_wait);

	INIT_LIST_HEAD(&chan->nvsw.flip);

	INIT_LIST_HEAD(&chan->fence.pending);

	spin_lock_init(&chan->fence.lock);



	/* setup channel's memory and vm */

	ret = nouveau_gpuobj_channel_init(chan, vram_handle, gart_handle);
@@ -190,18 +190,13 @@ nouveau_channel_alloc(struct drm_device *dev, struct nouveau_channel **chan_ret, 
	if (dev_priv->card_type >= NV_50)

		chan->user_get_hi = 0x60;



	/* disable the fifo caches */

	pfifo->reassign(dev, false);



	/* Construct initial RAMFC for new channel */

	ret = pfifo->create_context(chan);

	/* create fifo context */

	ret = pfifo->base.context_new(chan, NVOBJ_ENGINE_FIFO);

	if (ret) {

		nouveau_channel_put(&chan);

		return ret;

	}



	pfifo->reassign(dev, true);



	/* Insert NOPs for NOUVEAU_DMA_SKIPS */

	ret = RING_SPACE(chan, NOUVEAU_DMA_SKIPS);

	if (ret) {
@@ -211,9 +206,28 @@ nouveau_channel_alloc(struct drm_device *dev, struct nouveau_channel **chan_ret, 


	for (i = 0; i < NOUVEAU_DMA_SKIPS; i++)

		OUT_RING  (chan, 0x00000000);



	ret = nouveau_gpuobj_gr_new(chan, NvSw, nouveau_software_class(dev));

	if (ret) {

		nouveau_channel_put(&chan);

		return ret;

	}



	if (dev_priv->card_type < NV_C0) {

		ret = RING_SPACE(chan, 2);

		if (ret) {

			nouveau_channel_put(&chan);

			return ret;

		}



		BEGIN_NV04(chan, NvSubSw, NV01_SUBCHAN_OBJECT, 1);

		OUT_RING  (chan, NvSw);

		FIRE_RING (chan);

	}



	ret = nouveau_fence_channel_init(chan);

	FIRE_RING(chan);



	ret = fence->context_new(chan, NVOBJ_ENGINE_FENCE);

	if (ret) {

		nouveau_channel_put(&chan);

		return ret;
@@ -268,7 +282,6 @@ nouveau_channel_put_unlocked(struct nouveau_channel **pchan) 
	struct nouveau_channel *chan = *pchan;

	struct drm_device *dev = chan->dev;

	struct drm_nouveau_private *dev_priv = dev->dev_private;

	struct nouveau_fifo_engine *pfifo = &dev_priv->engine.fifo;

	unsigned long flags;

	int i;
@@ -285,24 +298,12 @@ nouveau_channel_put_unlocked(struct nouveau_channel **pchan) 
	/* give it chance to idle */

	nouveau_channel_idle(chan);



	/* ensure all outstanding fences are signaled.  they should be if the

	 * above attempts at idling were OK, but if we failed this'll tell TTM

	 * we're done with the buffers.

	 */

	nouveau_fence_channel_fini(chan);



	/* boot it off the hardware */

	pfifo->reassign(dev, false);



	/* destroy the engine specific contexts */

	pfifo->destroy_context(chan);

	for (i = 0; i < NVOBJ_ENGINE_NR; i++) {

	for (i = NVOBJ_ENGINE_NR - 1; i >= 0; i--) {

		if (chan->engctx[i])

			dev_priv->eng[i]->context_del(chan, i);

	}



	pfifo->reassign(dev, true);



	/* aside from its resources, the channel should now be dead,

	 * remove it from the channel list

	 */
@@ -354,17 +355,14 @@ nouveau_channel_ref(struct nouveau_channel *chan, 
	*pchan = chan;

}



void

int

nouveau_channel_idle(struct nouveau_channel *chan)

{

	struct drm_device *dev = chan->dev;

	struct nouveau_fence *fence = NULL;

	int ret;



	nouveau_fence_update(chan);



	if (chan->fence.sequence != chan->fence.sequence_ack) {

		ret = nouveau_fence_new(chan, &fence, true);

	ret = nouveau_fence_new(chan, &fence);

	if (!ret) {

		ret = nouveau_fence_wait(fence, false, false);

		nouveau_fence_unref(&fence);
@@ -372,20 +370,22 @@ nouveau_channel_idle(struct nouveau_channel *chan) 


	if (ret)

		NV_ERROR(dev, "Failed to idle channel %d.\n", chan->id);

	}

	return ret;

}



/* cleans up all the fifos from file_priv */

void

nouveau_channel_cleanup(struct drm_device *dev, struct drm_file *file_priv)

{

	struct drm_nouveau_private *dev_priv = dev->dev_private;

	struct nouveau_engine *engine = &dev_priv->engine;

	struct nouveau_fifo_priv *pfifo = nv_engine(dev, NVOBJ_ENGINE_FIFO);

	struct nouveau_channel *chan;

	int i;



	if (!pfifo)

		return;



	NV_DEBUG(dev, "clearing FIFO enables from file_priv\n");

	for (i = 0; i < engine->fifo.channels; i++) {

	for (i = 0; i < pfifo->channels; i++) {

		chan = nouveau_channel_get(file_priv, i);

		if (IS_ERR(chan))

			continue;