Commit 920d2b5e authored by Ben Skeggs's avatar Ben Skeggs
Browse files

drm/nouveau/mmu: define user interfaces to mmu vmm opertaions 



Signed-off-by: default avatarBen Skeggs <bskeggs@redhat.com>
parent c83c4097

drivers/gpu/drm/nouveau/include/nvif/if000c.h

+61 −0
Original line number Diff line number Diff line 
#ifndef __NVIF_IF000C_H__

#define __NVIF_IF000C_H__

struct nvif_vmm_v0 {

	__u8  version;

	__u8  page_nr;

	__u8  pad02[6];

	__u64 addr;

	__u64 size;

	__u8  data[];

};



#define NVIF_VMM_V0_PAGE                                                   0x00

#define NVIF_VMM_V0_GET                                                    0x01

#define NVIF_VMM_V0_PUT                                                    0x02

#define NVIF_VMM_V0_MAP                                                    0x03

#define NVIF_VMM_V0_UNMAP                                                  0x04



struct nvif_vmm_page_v0 {

	__u8  version;

	__u8  index;

	__u8  shift;

	__u8  sparse;

	__u8  vram;

	__u8  host;

	__u8  comp;

	__u8  pad07[1];

};



struct nvif_vmm_get_v0 {

	__u8  version;

#define NVIF_VMM_GET_V0_ADDR                                               0x00

#define NVIF_VMM_GET_V0_PTES                                               0x01

#define NVIF_VMM_GET_V0_LAZY	                                           0x02

	__u8  type;

	__u8  sparse;

	__u8  page;

	__u8  align;

	__u8  pad05[3];

	__u64 size;

	__u64 addr;

};



struct nvif_vmm_put_v0 {

	__u8  version;

	__u8  pad01[7];

	__u64 addr;

};



struct nvif_vmm_map_v0 {

	__u8  version;

	__u8  pad01[7];

	__u64 addr;

	__u64 size;

	__u64 memory;

	__u64 offset;

	__u8  data[];

};



struct nvif_vmm_unmap_v0 {

	__u8  version;

	__u8  pad01[7];

	__u64 addr;

};

#endif

drivers/gpu/drm/nouveau/include/nvif/vmm.h

0 → 100644
+42 −0
Original line number Diff line number Diff line 
#ifndef __NVIF_VMM_H__

#define __NVIF_VMM_H__

#include <nvif/object.h>

struct nvif_mem;

struct nvif_mmu;



enum nvif_vmm_get {

	ADDR,

	PTES,

	LAZY

};



struct nvif_vma {

	u64 addr;

	u64 size;

};



struct nvif_vmm {

	struct nvif_object object;

	u64 start;

	u64 limit;



	struct {

		u8 shift;

		bool sparse:1;

		bool vram:1;

		bool host:1;

		bool comp:1;

	} *page;

	int page_nr;

};



int nvif_vmm_init(struct nvif_mmu *, s32 oclass, u64 addr, u64 size,

		  void *argv, u32 argc, struct nvif_vmm *);

void nvif_vmm_fini(struct nvif_vmm *);

int nvif_vmm_get(struct nvif_vmm *, enum nvif_vmm_get, bool sparse,

		 u8 page, u8 align, u64 size, struct nvif_vma *);

void nvif_vmm_put(struct nvif_vmm *, struct nvif_vma *);

int nvif_vmm_map(struct nvif_vmm *, u64 addr, u64 size, void *argv, u32 argc,

		 struct nvif_mem *, u64 offset);

int nvif_vmm_unmap(struct nvif_vmm *, u64);

#endif

drivers/gpu/drm/nouveau/nvif/Kbuild

+1 −0
Original line number Diff line number Diff line
@@ -5,3 +5,4 @@ nvif-y += nvif/driver.o 
nvif-y += nvif/mem.o

nvif-y += nvif/mmu.o

nvif-y += nvif/notify.o

nvif-y += nvif/vmm.o

drivers/gpu/drm/nouveau/nvif/vmm.c

0 → 100644
+167 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2017 Red Hat Inc.

 *

 * 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 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 HOLDER(S) OR AUTHOR(S) 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.

 */

#include <nvif/vmm.h>

#include <nvif/mem.h>



#include <nvif/if000c.h>



int

nvif_vmm_unmap(struct nvif_vmm *vmm, u64 addr)

{

	return nvif_object_mthd(&vmm->object, NVIF_VMM_V0_UNMAP,

				&(struct nvif_vmm_unmap_v0) { .addr = addr },

				sizeof(struct nvif_vmm_unmap_v0));

}



int

nvif_vmm_map(struct nvif_vmm *vmm, u64 addr, u64 size, void *argv, u32 argc,

	     struct nvif_mem *mem, u64 offset)

{

	struct nvif_vmm_map_v0 *args;

	u8 stack[16];

	int ret;



	if (sizeof(*args) + argc > sizeof(stack)) {

		if (!(args = kmalloc(sizeof(*args) + argc, GFP_KERNEL)))

			return -ENOMEM;

	} else {

		args = (void *)stack;

	}



	args->version = 0;

	args->addr = addr;

	args->size = size;

	args->memory = nvif_handle(&mem->object);

	args->offset = offset;

	memcpy(args->data, argv, argc);



	ret = nvif_object_mthd(&vmm->object, NVIF_VMM_V0_MAP,

			       args, sizeof(*args) + argc);

	if (args != (void *)stack)

		kfree(args);

	return ret;

}



void

nvif_vmm_put(struct nvif_vmm *vmm, struct nvif_vma *vma)

{

	if (vma->size) {

		WARN_ON(nvif_object_mthd(&vmm->object, NVIF_VMM_V0_PUT,

					 &(struct nvif_vmm_put_v0) {

						.addr = vma->addr,

					 }, sizeof(struct nvif_vmm_put_v0)));

		vma->size = 0;

	}

}



int

nvif_vmm_get(struct nvif_vmm *vmm, enum nvif_vmm_get type, bool sparse,

	     u8 page, u8 align, u64 size, struct nvif_vma *vma)

{

	struct nvif_vmm_get_v0 args;

	int ret;



	args.version = vma->size = 0;

	args.sparse = sparse;

	args.page = page;

	args.align = align;

	args.size = size;



	switch (type) {

	case ADDR: args.type = NVIF_VMM_GET_V0_ADDR; break;

	case PTES: args.type = NVIF_VMM_GET_V0_PTES; break;

	case LAZY: args.type = NVIF_VMM_GET_V0_LAZY; break;

	default:

		WARN_ON(1);

		return -EINVAL;

	}



	ret = nvif_object_mthd(&vmm->object, NVIF_VMM_V0_GET,

			       &args, sizeof(args));

	if (ret == 0) {

		vma->addr = args.addr;

		vma->size = args.size;

	}

	return ret;

}



void

nvif_vmm_fini(struct nvif_vmm *vmm)

{

	kfree(vmm->page);

	nvif_object_fini(&vmm->object);

}



int

nvif_vmm_init(struct nvif_mmu *mmu, s32 oclass, u64 addr, u64 size,

	      void *argv, u32 argc, struct nvif_vmm *vmm)

{

	struct nvif_vmm_v0 *args;

	u32 argn = sizeof(*args) + argc;

	int ret = -ENOSYS, i;



	vmm->object.client = NULL;

	vmm->page = NULL;



	if (!(args = kmalloc(argn, GFP_KERNEL)))

		return -ENOMEM;

	args->version = 0;

	args->addr = addr;

	args->size = size;

	memcpy(args->data, argv, argc);



	ret = nvif_object_init(&mmu->object, 0, oclass, args, argn,

			       &vmm->object);

	if (ret)

		goto done;



	vmm->start = args->addr;

	vmm->limit = args->size;



	vmm->page_nr = args->page_nr;

	vmm->page = kmalloc(sizeof(*vmm->page) * vmm->page_nr, GFP_KERNEL);

	if (!vmm->page) {

		ret = -ENOMEM;

		goto done;

	}



	for (i = 0; i < vmm->page_nr; i++) {

		struct nvif_vmm_page_v0 args = { .index = i };



		ret = nvif_object_mthd(&vmm->object, NVIF_VMM_V0_PAGE,

				       &args, sizeof(args));

		if (ret)

			break;



		vmm->page[i].shift = args.shift;

		vmm->page[i].sparse = args.sparse;

		vmm->page[i].vram = args.vram;

		vmm->page[i].host = args.host;

		vmm->page[i].comp = args.comp;

	}



done:

	if (ret)

		nvif_vmm_fini(vmm);

	kfree(args);

	return ret;

}

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/Kbuild

+1 −0
Original line number Diff line number Diff line
@@ -32,3 +32,4 @@ nvkm-y += nvkm/subdev/mmu/vmmgp10b.o 


nvkm-y += nvkm/subdev/mmu/umem.o

nvkm-y += nvkm/subdev/mmu/ummu.o

nvkm-y += nvkm/subdev/mmu/uvmm.o