Commit 9274f4a9 authored by Ben Skeggs's avatar Ben Skeggs
Browse files

drm/nouveau/core: pull in most of the new core infrastructure 



This commit provides most of the infrastructure to support a major overhaul
of Nouveau's internals coming in the following commits.  This work aims to
take all the things we've learned over the last several years, and turn that
into a cleaner architecture that's more maintainable going forward.

RAMHT and MM bits of the new core have been left out for the moment, and
will be pulled in as I go through the process of porting the code to
become either subdev or engine modules.

There are several main goals I wanted to achieve through this work:

-- Reduce complexity

The goal here was to make each component of the driver as independent as
possible, which will ease maintainability and readability, and provide a
good base for resetting locked up GPU units in the future.

-- Better tracking of GPU units that are required at any given time

This is for future PM work, we'll be able to tell exactly what parts of the
GPU we need powered at any given point (etc).

-- Expose all available NVIDIA GPUs to the client

In order to support things such as multi-GPU channels, we want to be able
to expose all the NVIDIA GPUs to the client over a single file descriptor
so it can send a single push buffer to multiple GPUs.

-- Untangle the core hardware support code from the DRM implementation

This happened initially as an unexpected side-effect of developing the
initial core infrastructure in userspace, but it turned into a goal of
the whole project.  Initial benefits will be the availablility of a
number of userspace tools and tests using the same code as the driver
itself, but will also be important as I look into some virtualisation
ideas.

v2: Ben Skeggs <bskeggs@redhat.com>
- fix duplicate assignments noticed by clang
- implement some forgotten yelling in error path
- ensure 64-bit engine mask is used everywhere

v3: Marcin Slusarz <marcin.slusarz@gmail.com>
- sparse fixes
- inline nv_printk into nv_assert to prevent recursive inlining issues

v4: Ben Skeggs <bskeggs@redhat.com>
- fixed minor memory leak on gpuobj destruction

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

drivers/gpu/drm/nouveau/Makefile

+20 −2
Original line number Diff line number Diff line
@@ -2,13 +2,31 @@ 
# Makefile for the drm device driver.  This driver provides support for the

# Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.



ccflags-y := -Iinclude/drm

ccflags-y := -Iinclude/drm -DCONFIG_NOUVEAU_DEBUG=7 -DCONFIG_NOUVEAU_DEBUG_DEFAULT=3

ccflags-y += -I$(src)/core/include

ccflags-y += -I$(src)



nouveau-y := core/core/mm.o

nouveau-y := core/core/client.o

nouveau-y += core/core/engine.o

nouveau-y += core/core/handle.o

nouveau-y += core/core/mm.o

nouveau-y += core/core/namedb.o

nouveau-y += core/core/object.o

nouveau-y += core/core/option.o

nouveau-y += core/core/parent.o

nouveau-y += core/core/printk.o

nouveau-y += core/core/ramht.o

nouveau-y += core/core/subdev.o



nouveau-y += core/subdev/device/base.o

nouveau-y += core/subdev/device/nv04.o

nouveau-y += core/subdev/device/nv10.o

nouveau-y += core/subdev/device/nv20.o

nouveau-y += core/subdev/device/nv30.o

nouveau-y += core/subdev/device/nv40.o

nouveau-y += core/subdev/device/nv50.o

nouveau-y += core/subdev/device/nvc0.o

nouveau-y += core/subdev/device/nve0.o

nouveau-y += core/subdev/fb/nv04.o

nouveau-y += core/subdev/fb/nv10.o

nouveau-y += core/subdev/fb/nv20.o

drivers/gpu/drm/nouveau/core/core/client.c

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

 * Copyright 2012 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.

 *

 * Authors: Ben Skeggs

 */



#include <core/object.h>

#include <core/client.h>

#include <core/handle.h>

#include <core/option.h>



#include <subdev/device.h>



static void

nouveau_client_dtor(struct nouveau_object *object)

{

	struct nouveau_client *client = (void *)object;

	nouveau_object_ref(NULL, &client->device);

	nouveau_handle_destroy(client->root);

	nouveau_namedb_destroy(&client->base);

}



static struct nouveau_oclass

nouveau_client_oclass = {

	.ofuncs = &(struct nouveau_ofuncs) {

		.dtor = nouveau_client_dtor,

	},

};



int

nouveau_client_create_(u32 name, u64 devname, const char *cfg, const char *dbg,

		       int length, void **pobject)

{

	struct nouveau_object *device;

	struct nouveau_client *client;

	int ret;



	device = (void *)nouveau_device_find(devname);

	if (!device)

		return -ENODEV;



	ret = nouveau_namedb_create_(NULL, NULL, &nouveau_client_oclass,

				     NV_CLIENT_CLASS, nouveau_device_sclass,

				     0, length, pobject);

	client = *pobject;

	if (ret)

		return ret;



	ret = nouveau_handle_create(nv_object(client), ~0, ~0,

				    nv_object(client), &client->root);

	if (ret) {

		nouveau_namedb_destroy(&client->base);

		return ret;

	}



	/* prevent init/fini being called, os in in charge of this */

	atomic_set(&nv_object(client)->usecount, 2);



	nouveau_object_ref(device, &client->device);

	client->handle = name;

	client->debug = nouveau_dbgopt(dbg, "CLIENT");

	return 0;

}



int

nouveau_client_init(struct nouveau_client *client)

{

	int ret;

	nv_debug(client, "init running\n");

	ret = nouveau_handle_init(client->root);

	nv_debug(client, "init completed with %d\n", ret);

	return ret;

}



int

nouveau_client_fini(struct nouveau_client *client, bool suspend)

{

	const char *name[2] = { "fini", "suspend" };

	int ret;



	nv_debug(client, "%s running\n", name[suspend]);

	ret = nouveau_handle_fini(client->root, suspend);

	nv_debug(client, "%s completed with %d\n", name[suspend], ret);

	return ret;

}

drivers/gpu/drm/nouveau/core/core/engctx.c

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

 * Copyright 2012 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.

 *

 * Authors: Ben Skeggs

 */



#include <core/object.h>

#include <core/namedb.h>

#include <core/handle.h>

#include <core/client.h>

#include <core/engctx.h>



#include <subdev/vm.h>



int

nouveau_engctx_create_(struct nouveau_object *parent,

		       struct nouveau_object *engobj,

		       struct nouveau_oclass *oclass,

		       struct nouveau_object *pargpu,

		       u32 size, u32 align, u32 flags,

		       int length, void **pobject)

{

	struct nouveau_client *client = nouveau_client(parent);

	struct nouveau_engine *engine = nv_engine(engobj);

	struct nouveau_subdev *subdev = nv_subdev(engine);

	struct nouveau_engctx *engctx;

	struct nouveau_object *ctxpar;

	int ret;



	/* use existing context for the engine if one is available */

	mutex_lock(&subdev->mutex);

	list_for_each_entry(engctx, &engine->contexts, head) {

		ctxpar = nv_pclass(nv_object(engctx), NV_PARENT_CLASS);

		if (ctxpar == parent) {

			atomic_inc(&nv_object(engctx)->refcount);

			*pobject = engctx;

			mutex_unlock(&subdev->mutex);

			return 1;

		}

	}

	mutex_unlock(&subdev->mutex);



	if (size) {

		ret = nouveau_gpuobj_create_(parent, engobj, oclass,

					     NV_ENGCTX_CLASS,

					     pargpu, size, align, flags,

					     length, pobject);

	} else {

		ret = nouveau_object_create_(parent, engobj, oclass,

					     NV_ENGCTX_CLASS, length, pobject);

	}



	engctx = *pobject;

	if (engctx && client->vm)

		atomic_inc(&client->vm->engref[nv_engidx(engobj)]);

	if (ret)

		return ret;



	list_add(&engctx->head, &engine->contexts);

	return 0;

}



void

nouveau_engctx_destroy(struct nouveau_engctx *engctx)

{

	struct nouveau_object *engine = nv_object(engctx)->engine;

	struct nouveau_client *client = nouveau_client(engctx);



	nouveau_gpuobj_unmap(&engctx->vma);

	list_del(&engctx->head);

	if (client->vm)

		atomic_dec(&client->vm->engref[nv_engidx(engine)]);



	if (engctx->base.size)

		nouveau_gpuobj_destroy(&engctx->base);

	else

		nouveau_object_destroy(&engctx->base.base);

}



int

nouveau_engctx_init(struct nouveau_engctx *engctx)

{

	struct nouveau_object *object = nv_object(engctx);

	struct nouveau_subdev *subdev = nv_subdev(object->engine);

	struct nouveau_object *parent;

	struct nouveau_subdev *pardev;

	int ret;



	ret = nouveau_gpuobj_init(&engctx->base);

	if (ret)

		return ret;



	parent = nv_pclass(object->parent, NV_PARENT_CLASS);

	pardev = nv_subdev(parent->engine);

	if (nv_parent(parent)->context_attach) {

		mutex_lock(&pardev->mutex);

		ret = nv_parent(parent)->context_attach(parent, object);

		mutex_unlock(&pardev->mutex);

	}



	if (ret) {

		nv_error(parent, "failed to attach %s context, %d\n",

			 subdev->name, ret);

		return ret;

	}



	nv_debug(parent, "attached %s context\n", subdev->name);

	return 0;

}



int

nouveau_engctx_fini(struct nouveau_engctx *engctx, bool suspend)

{

	struct nouveau_object *object = nv_object(engctx);

	struct nouveau_subdev *subdev = nv_subdev(object->engine);

	struct nouveau_object *parent;

	struct nouveau_subdev *pardev;

	int ret = 0;



	parent = nv_pclass(object->parent, NV_PARENT_CLASS);

	pardev = nv_subdev(parent->engine);

	if (nv_parent(parent)->context_detach) {

		mutex_lock(&pardev->mutex);

		ret = nv_parent(parent)->context_detach(parent, suspend, object);

		mutex_unlock(&pardev->mutex);

	}



	if (ret) {

		nv_error(parent, "failed to detach %s context, %d\n",

			 subdev->name, ret);

		return ret;

	}



	nv_debug(parent, "detached %s context\n", subdev->name);

	return nouveau_gpuobj_fini(&engctx->base, suspend);

}



void

_nouveau_engctx_dtor(struct nouveau_object *object)

{

	nouveau_engctx_destroy(nv_engctx(object));

}



int

_nouveau_engctx_init(struct nouveau_object *object)

{

	return nouveau_engctx_init(nv_engctx(object));

}





int

_nouveau_engctx_fini(struct nouveau_object *object, bool suspend)

{

	return nouveau_engctx_fini(nv_engctx(object), suspend);

}



struct nouveau_object *

nouveau_engctx_lookup(struct nouveau_engine *engine, u64 addr)

{

	struct nouveau_engctx *engctx;



	list_for_each_entry(engctx, &engine->contexts, head) {

		if (engctx->base.size &&

		    nv_gpuobj(engctx)->addr == addr)

			return nv_object(engctx);

	}



	return NULL;

}



struct nouveau_handle *

nouveau_engctx_lookup_class(struct nouveau_engine *engine, u64 addr, u16 oclass)

{

	struct nouveau_object *engctx = nouveau_engctx_lookup(engine, addr);

	struct nouveau_namedb *namedb;



	if (engctx && (namedb = (void *)nv_pclass(engctx, NV_NAMEDB_CLASS)))

		return nouveau_namedb_get_class(namedb, oclass);



	return NULL;

}



struct nouveau_handle *

nouveau_engctx_lookup_vinst(struct nouveau_engine *engine, u64 addr, u64 vinst)

{

	struct nouveau_object *engctx = nouveau_engctx_lookup(engine, addr);

	struct nouveau_namedb *namedb;



	if (engctx && (namedb = (void *)nv_pclass(engctx, NV_NAMEDB_CLASS)))

		return nouveau_namedb_get_vinst(namedb, vinst);



	return NULL;

}



struct nouveau_handle *

nouveau_engctx_lookup_cinst(struct nouveau_engine *engine, u64 addr, u32 cinst)

{

	struct nouveau_object *engctx = nouveau_engctx_lookup(engine, addr);

	struct nouveau_namedb *namedb;



	if (engctx && (namedb = (void *)nv_pclass(engctx, NV_NAMEDB_CLASS)))

		return nouveau_namedb_get_cinst(namedb, cinst);



	return NULL;

}



void

nouveau_engctx_handle_put(struct nouveau_handle *handle)

{

	if (handle)

		nouveau_namedb_put(handle);

}

drivers/gpu/drm/nouveau/core/core/engine.c

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

 * Copyright 2012 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.

 *

 * Authors: Ben Skeggs

 */



#include <core/device.h>

#include <core/engine.h>

#include <core/option.h>



int

nouveau_engine_create_(struct nouveau_object *parent,

		       struct nouveau_object *engobj,

		       struct nouveau_oclass *oclass, bool enable,

		       const char *iname, const char *fname,

		       int length, void **pobject)

{

	struct nouveau_device *device = nv_device(parent);

	struct nouveau_engine *engine;

	int ret;



	ret = nouveau_subdev_create_(parent, engobj, oclass, NV_ENGINE_CLASS,

				     iname, fname, length, pobject);

	engine = *pobject;

	if (ret)

		return ret;



	if (!nouveau_boolopt(device->cfgopt, iname, enable)) {

		if (!enable)

			nv_warn(engine, "disabled, %s=1 to enable\n", iname);

		return -ENODEV;

	}



	INIT_LIST_HEAD(&engine->contexts);

	return 0;

}

drivers/gpu/drm/nouveau/core/core/enum.c

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

 * Copyright (C) 2010 Nouveau Project

 *

 * 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.

 *

 */



#include <core/os.h>

#include <core/enum.h>



const struct nouveau_enum *

nouveau_enum_find(const struct nouveau_enum *en, u32 value)

{

	while (en->name) {

		if (en->value == value)

			return en;

		en++;

	}



	return NULL;

}



void

nouveau_enum_print(const struct nouveau_enum *en, u32 value)

{

	en = nouveau_enum_find(en, value);

	if (en)

		printk("%s", en->name);

	else

		printk("(unknown enum 0x%08x)", value);

}



void

nouveau_bitfield_print(const struct nouveau_bitfield *bf, u32 value)

{

	while (bf->name) {

		if (value & bf->mask) {

			printk(" %s", bf->name);

			value &= ~bf->mask;

		}



		bf++;

	}



	if (value)

		printk(" (unknown bits 0x%08x)", value);

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE