From 5025407b9862349d17b1dff25737aaef6520a439 Mon Sep 17 00:00:00 2001 From: Ben Skeggs Date: Wed, 14 Jan 2015 14:11:21 +1000 Subject: drm/nouveau/core: namespace + nvidia gpu names (no binary change) The namespace of NVKM is being changed to nvkm_ instead of nouveau_, which will be used for the DRM part of the driver. This is being done in order to make it very clear as to what part of the driver a given symbol belongs to, and as a minor step towards splitting the DRM driver out to be able to stand on its own (for virt). Because there's already a large amount of churn here anyway, this is as good a time as any to also switch to NVIDIA's device and chipset naming to ease collaboration with them. A comparison of objdump disassemblies proves no code changes. Signed-off-by: Ben Skeggs diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/client.h b/drivers/gpu/drm/nouveau/include/nvkm/core/client.h index 827c4e9..a35b382 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/client.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/client.h @@ -1,15 +1,14 @@ -#ifndef __NOUVEAU_CLIENT_H__ -#define __NOUVEAU_CLIENT_H__ - +#ifndef __NVKM_CLIENT_H__ +#define __NVKM_CLIENT_H__ #include -struct nouveau_client { - struct nouveau_namedb namedb; - struct nouveau_handle *root; - struct nouveau_object *device; +struct nvkm_client { + struct nvkm_namedb namedb; + struct nvkm_handle *root; + struct nvkm_object *device; char name[32]; u32 debug; - struct nouveau_vm *vm; + struct nvkm_vm *vm; bool super; void *data; @@ -17,7 +16,7 @@ struct nouveau_client { struct nvkm_client_notify *notify[16]; }; -static inline struct nouveau_client * +static inline struct nvkm_client * nv_client(void *obj) { #if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA @@ -27,31 +26,30 @@ nv_client(void *obj) return obj; } -static inline struct nouveau_client * -nouveau_client(void *obj) +static inline struct nvkm_client * +nvkm_client(void *obj) { - struct nouveau_object *client = nv_object(obj); + struct nvkm_object *client = nv_object(obj); while (client && !(nv_iclass(client, NV_CLIENT_CLASS))) client = client->parent; return (void *)client; } -#define nouveau_client_create(n,c,oc,od,d) \ - nouveau_client_create_((n), (c), (oc), (od), sizeof(**d), (void **)d) +#define nvkm_client_create(n,c,oc,od,d) \ + nvkm_client_create_((n), (c), (oc), (od), sizeof(**d), (void **)d) -int nouveau_client_create_(const char *name, u64 device, const char *cfg, +int nvkm_client_create_(const char *name, u64 device, const char *cfg, const char *dbg, int, void **); -#define nouveau_client_destroy(p) \ - nouveau_namedb_destroy(&(p)->base) +#define nvkm_client_destroy(p) \ + nvkm_namedb_destroy(&(p)->base) -int nouveau_client_init(struct nouveau_client *); -int nouveau_client_fini(struct nouveau_client *, bool suspend); -const char *nouveau_client_name(void *obj); +int nvkm_client_init(struct nvkm_client *); +int nvkm_client_fini(struct nvkm_client *, bool suspend); +const char *nvkm_client_name(void *obj); -int nvkm_client_notify_new(struct nouveau_object *, struct nvkm_event *, +int nvkm_client_notify_new(struct nvkm_object *, struct nvkm_event *, void *data, u32 size); -int nvkm_client_notify_del(struct nouveau_client *, int index); -int nvkm_client_notify_get(struct nouveau_client *, int index); -int nvkm_client_notify_put(struct nouveau_client *, int index); - +int nvkm_client_notify_del(struct nvkm_client *, int index); +int nvkm_client_notify_get(struct nvkm_client *, int index); +int nvkm_client_notify_put(struct nvkm_client *, int index); #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/debug.h b/drivers/gpu/drm/nouveau/include/nvkm/core/debug.h index 8092e2e..d07cb86 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/debug.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/debug.h @@ -1,6 +1,5 @@ -#ifndef __NOUVEAU_DEBUG_H__ -#define __NOUVEAU_DEBUG_H__ - +#ifndef __NVKM_DEBUG_H__ +#define __NVKM_DEBUG_H__ extern int nv_info_debug_level; #define NV_DBG_FATAL 0 @@ -16,5 +15,4 @@ extern int nv_info_debug_level; #define NV_DBG_INFO_SILENT NV_DBG_DEBUG #define nv_debug_level(a) nv_info_debug_level = NV_DBG_INFO_##a - #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/device.h b/drivers/gpu/drm/nouveau/include/nvkm/core/device.h index 23d71c5..9c2f136 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/device.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/device.h @@ -1,13 +1,10 @@ -#ifndef __NOUVEAU_DEVICE_H__ -#define __NOUVEAU_DEVICE_H__ - -#include -#include +#ifndef __NVKM_DEVICE_H__ +#define __NVKM_DEVICE_H__ #include #include -struct nouveau_device { - struct nouveau_engine engine; +struct nvkm_device { + struct nvkm_engine engine; struct list_head head; struct pci_dev *pdev; @@ -38,53 +35,53 @@ struct nouveau_device { u8 chiprev; u32 crystal; - struct nouveau_oclass *oclass[NVDEV_SUBDEV_NR]; - struct nouveau_object *subdev[NVDEV_SUBDEV_NR]; + struct nvkm_oclass *oclass[NVDEV_SUBDEV_NR]; + struct nvkm_object *subdev[NVDEV_SUBDEV_NR]; struct { struct notifier_block nb; } acpi; }; -int nouveau_device_list(u64 *name, int size); +struct nvkm_device *nvkm_device_find(u64 name); +int nvkm_device_list(u64 *name, int size); -struct nouveau_device *nv_device(void *obj); +struct nvkm_device *nv_device(void *obj); static inline bool -nv_device_match(struct nouveau_object *object, u16 dev, u16 ven, u16 sub) +nv_device_match(struct nvkm_object *object, u16 dev, u16 ven, u16 sub) { - struct nouveau_device *device = nv_device(object); + struct nvkm_device *device = nv_device(object); return device->pdev->device == dev && device->pdev->subsystem_vendor == ven && device->pdev->subsystem_device == sub; } static inline bool -nv_device_is_pci(struct nouveau_device *device) +nv_device_is_pci(struct nvkm_device *device) { return device->pdev != NULL; } static inline bool -nv_device_is_cpu_coherent(struct nouveau_device *device) +nv_device_is_cpu_coherent(struct nvkm_device *device) { return (!IS_ENABLED(CONFIG_ARM) && nv_device_is_pci(device)); } static inline struct device * -nv_device_base(struct nouveau_device *device) +nv_device_base(struct nvkm_device *device) { return nv_device_is_pci(device) ? &device->pdev->dev : &device->platformdev->dev; } resource_size_t -nv_device_resource_start(struct nouveau_device *device, unsigned int bar); +nv_device_resource_start(struct nvkm_device *device, unsigned int bar); resource_size_t -nv_device_resource_len(struct nouveau_device *device, unsigned int bar); +nv_device_resource_len(struct nvkm_device *device, unsigned int bar); int -nv_device_get_irq(struct nouveau_device *device, bool stall); - +nv_device_get_irq(struct nvkm_device *device, bool stall); #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/engctx.h b/drivers/gpu/drm/nouveau/include/nvkm/core/engctx.h index 9d696e4..1bf2e8e 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/engctx.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/engctx.h @@ -1,7 +1,5 @@ -#ifndef __NOUVEAU_ENGCTX_H__ -#define __NOUVEAU_ENGCTX_H__ - -#include +#ifndef __NVKM_ENGCTX_H__ +#define __NVKM_ENGCTX_H__ #include #include @@ -9,15 +7,15 @@ #define NV_ENGCTX_(eng,var) (NV_ENGCTX_CLASS | ((var) << 8) | (eng)) #define NV_ENGCTX(name,var) NV_ENGCTX_(NVDEV_ENGINE_##name, (var)) -struct nouveau_engctx { - struct nouveau_gpuobj gpuobj; - struct nouveau_vma vma; +struct nvkm_engctx { + struct nvkm_gpuobj gpuobj; + struct nvkm_vma vma; struct list_head head; unsigned long save; u64 addr; }; -static inline struct nouveau_engctx * +static inline struct nvkm_engctx * nv_engctx(void *obj) { #if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA @@ -27,28 +25,27 @@ nv_engctx(void *obj) return obj; } -#define nouveau_engctx_create(p,e,c,g,s,a,f,d) \ - nouveau_engctx_create_((p), (e), (c), (g), (s), (a), (f), \ +#define nvkm_engctx_create(p,e,c,g,s,a,f,d) \ + nvkm_engctx_create_((p), (e), (c), (g), (s), (a), (f), \ sizeof(**d), (void **)d) -int nouveau_engctx_create_(struct nouveau_object *, struct nouveau_object *, - struct nouveau_oclass *, struct nouveau_object *, +int nvkm_engctx_create_(struct nvkm_object *, struct nvkm_object *, + struct nvkm_oclass *, struct nvkm_object *, u32 size, u32 align, u32 flags, int length, void **data); -void nouveau_engctx_destroy(struct nouveau_engctx *); -int nouveau_engctx_init(struct nouveau_engctx *); -int nouveau_engctx_fini(struct nouveau_engctx *, bool suspend); - -int _nouveau_engctx_ctor(struct nouveau_object *, struct nouveau_object *, - struct nouveau_oclass *, void *, u32, - struct nouveau_object **); -void _nouveau_engctx_dtor(struct nouveau_object *); -int _nouveau_engctx_init(struct nouveau_object *); -int _nouveau_engctx_fini(struct nouveau_object *, bool suspend); -#define _nouveau_engctx_rd32 _nouveau_gpuobj_rd32 -#define _nouveau_engctx_wr32 _nouveau_gpuobj_wr32 - -struct nouveau_object *nouveau_engctx_get(struct nouveau_engine *, u64 addr); -void nouveau_engctx_put(struct nouveau_object *); - +void nvkm_engctx_destroy(struct nvkm_engctx *); +int nvkm_engctx_init(struct nvkm_engctx *); +int nvkm_engctx_fini(struct nvkm_engctx *, bool suspend); + +int _nvkm_engctx_ctor(struct nvkm_object *, struct nvkm_object *, + struct nvkm_oclass *, void *, u32, + struct nvkm_object **); +void _nvkm_engctx_dtor(struct nvkm_object *); +int _nvkm_engctx_init(struct nvkm_object *); +int _nvkm_engctx_fini(struct nvkm_object *, bool suspend); +#define _nvkm_engctx_rd32 _nvkm_gpuobj_rd32 +#define _nvkm_engctx_wr32 _nvkm_gpuobj_wr32 + +struct nvkm_object *nvkm_engctx_get(struct nvkm_engine *, u64 addr); +void nvkm_engctx_put(struct nvkm_object *); #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/engine.h b/drivers/gpu/drm/nouveau/include/nvkm/core/engine.h index d7ebd35..faf0fd2 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/engine.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/engine.h @@ -1,25 +1,23 @@ -#ifndef __NOUVEAU_ENGINE_H__ -#define __NOUVEAU_ENGINE_H__ - -#include +#ifndef __NVKM_ENGINE_H__ +#define __NVKM_ENGINE_H__ #include #define NV_ENGINE_(eng,var) (NV_ENGINE_CLASS | ((var) << 8) | (eng)) #define NV_ENGINE(name,var) NV_ENGINE_(NVDEV_ENGINE_##name, (var)) -struct nouveau_engine { - struct nouveau_subdev subdev; - struct nouveau_oclass *cclass; - struct nouveau_oclass *sclass; +struct nvkm_engine { + struct nvkm_subdev subdev; + struct nvkm_oclass *cclass; + struct nvkm_oclass *sclass; struct list_head contexts; spinlock_t lock; - void (*tile_prog)(struct nouveau_engine *, int region); - int (*tlb_flush)(struct nouveau_engine *); + void (*tile_prog)(struct nvkm_engine *, int region); + int (*tlb_flush)(struct nvkm_engine *); }; -static inline struct nouveau_engine * +static inline struct nvkm_engine * nv_engine(void *obj) { #if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA @@ -30,30 +28,29 @@ nv_engine(void *obj) } static inline int -nv_engidx(struct nouveau_engine *engine) +nv_engidx(struct nvkm_engine *engine) { return nv_subidx(&engine->subdev); } -struct nouveau_engine *nouveau_engine(void *obj, int idx); +struct nvkm_engine *nvkm_engine(void *obj, int idx); -#define nouveau_engine_create(p,e,c,d,i,f,r) \ - nouveau_engine_create_((p), (e), (c), (d), (i), (f), \ +#define nvkm_engine_create(p,e,c,d,i,f,r) \ + nvkm_engine_create_((p), (e), (c), (d), (i), (f), \ sizeof(**r),(void **)r) -#define nouveau_engine_destroy(p) \ - nouveau_subdev_destroy(&(p)->subdev) -#define nouveau_engine_init(p) \ - nouveau_subdev_init(&(p)->subdev) -#define nouveau_engine_fini(p,s) \ - nouveau_subdev_fini(&(p)->subdev, (s)) +#define nvkm_engine_destroy(p) \ + nvkm_subdev_destroy(&(p)->subdev) +#define nvkm_engine_init(p) \ + nvkm_subdev_init(&(p)->subdev) +#define nvkm_engine_fini(p,s) \ + nvkm_subdev_fini(&(p)->subdev, (s)) -int nouveau_engine_create_(struct nouveau_object *, struct nouveau_object *, - struct nouveau_oclass *, bool, const char *, +int nvkm_engine_create_(struct nvkm_object *, struct nvkm_object *, + struct nvkm_oclass *, bool, const char *, const char *, int, void **); -#define _nouveau_engine_dtor _nouveau_subdev_dtor -#define _nouveau_engine_init _nouveau_subdev_init -#define _nouveau_engine_fini _nouveau_subdev_fini - +#define _nvkm_engine_dtor _nvkm_subdev_dtor +#define _nvkm_engine_init _nvkm_subdev_init +#define _nvkm_engine_fini _nvkm_subdev_fini #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/enum.h b/drivers/gpu/drm/nouveau/include/nvkm/core/enum.h index 4fc62bb..e76f76f 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/enum.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/enum.h @@ -1,24 +1,21 @@ -#ifndef __NOUVEAU_ENUM_H__ -#define __NOUVEAU_ENUM_H__ +#ifndef __NVKM_ENUM_H__ +#define __NVKM_ENUM_H__ +#include -struct nouveau_enum { +struct nvkm_enum { u32 value; const char *name; const void *data; u32 data2; }; -const struct nouveau_enum * -nouveau_enum_find(const struct nouveau_enum *, u32 value); +const struct nvkm_enum *nvkm_enum_find(const struct nvkm_enum *, u32 value); +const struct nvkm_enum *nvkm_enum_print(const struct nvkm_enum *, u32 value); -const struct nouveau_enum * -nouveau_enum_print(const struct nouveau_enum *en, u32 value); - -struct nouveau_bitfield { +struct nvkm_bitfield { u32 mask; const char *name; }; -void nouveau_bitfield_print(const struct nouveau_bitfield *, u32 value); - +void nvkm_bitfield_print(const struct nvkm_bitfield *, u32 value); #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/event.h b/drivers/gpu/drm/nouveau/include/nvkm/core/event.h index 9287652..b98fe2d 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/event.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/event.h @@ -1,15 +1,8 @@ #ifndef __NVKM_EVENT_H__ #define __NVKM_EVENT_H__ - -#include - -struct nvkm_event_func { - int (*ctor)(struct nouveau_object *, void *data, u32 size, - struct nvkm_notify *); - void (*send)(void *data, u32 size, struct nvkm_notify *); - void (*init)(struct nvkm_event *, int type, int index); - void (*fini)(struct nvkm_event *, int type, int index); -}; +#include +struct nvkm_notify; +struct nvkm_object; struct nvkm_event { const struct nvkm_event_func *func; @@ -23,13 +16,19 @@ struct nvkm_event { int *refs; }; -int nvkm_event_init(const struct nvkm_event_func *func, - int types_nr, int index_nr, - struct nvkm_event *); +struct nvkm_event_func { + int (*ctor)(struct nvkm_object *, void *data, u32 size, + struct nvkm_notify *); + void (*send)(void *data, u32 size, struct nvkm_notify *); + void (*init)(struct nvkm_event *, int type, int index); + void (*fini)(struct nvkm_event *, int type, int index); +}; + +int nvkm_event_init(const struct nvkm_event_func *func, int types_nr, + int index_nr, struct nvkm_event *); void nvkm_event_fini(struct nvkm_event *); void nvkm_event_get(struct nvkm_event *, u32 types, int index); void nvkm_event_put(struct nvkm_event *, u32 types, int index); void nvkm_event_send(struct nvkm_event *, u32 types, int index, void *data, u32 size); - #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/gpuobj.h b/drivers/gpu/drm/nouveau/include/nvkm/core/gpuobj.h index c262c25..e0187e7 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/gpuobj.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/gpuobj.h @@ -1,30 +1,26 @@ -#ifndef __NOUVEAU_GPUOBJ_H__ -#define __NOUVEAU_GPUOBJ_H__ - +#ifndef __NVKM_GPUOBJ_H__ +#define __NVKM_GPUOBJ_H__ #include -#include -#include #include - -struct nouveau_vma; -struct nouveau_vm; +struct nvkm_vma; +struct nvkm_vm; #define NVOBJ_FLAG_ZERO_ALLOC 0x00000001 #define NVOBJ_FLAG_ZERO_FREE 0x00000002 #define NVOBJ_FLAG_HEAP 0x00000004 -struct nouveau_gpuobj { - struct nouveau_object object; - struct nouveau_object *parent; - struct nouveau_mm_node *node; - struct nouveau_mm heap; +struct nvkm_gpuobj { + struct nvkm_object object; + struct nvkm_object *parent; + struct nvkm_mm_node *node; + struct nvkm_mm heap; u32 flags; u64 addr; u32 size; }; -static inline struct nouveau_gpuobj * +static inline struct nvkm_gpuobj * nv_gpuobj(void *obj) { #if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA @@ -34,38 +30,35 @@ nv_gpuobj(void *obj) return obj; } -#define nouveau_gpuobj_create(p,e,c,v,g,s,a,f,d) \ - nouveau_gpuobj_create_((p), (e), (c), (v), (g), (s), (a), (f), \ +#define nvkm_gpuobj_create(p,e,c,v,g,s,a,f,d) \ + nvkm_gpuobj_create_((p), (e), (c), (v), (g), (s), (a), (f), \ sizeof(**d), (void **)d) -#define nouveau_gpuobj_init(p) nouveau_object_init(&(p)->object) -#define nouveau_gpuobj_fini(p,s) nouveau_object_fini(&(p)->object, (s)) -int nouveau_gpuobj_create_(struct nouveau_object *, struct nouveau_object *, - struct nouveau_oclass *, u32 pclass, - struct nouveau_object *, u32 size, u32 align, +#define nvkm_gpuobj_init(p) nvkm_object_init(&(p)->object) +#define nvkm_gpuobj_fini(p,s) nvkm_object_fini(&(p)->object, (s)) +int nvkm_gpuobj_create_(struct nvkm_object *, struct nvkm_object *, + struct nvkm_oclass *, u32 pclass, + struct nvkm_object *, u32 size, u32 align, u32 flags, int length, void **); -void nouveau_gpuobj_destroy(struct nouveau_gpuobj *); +void nvkm_gpuobj_destroy(struct nvkm_gpuobj *); -int nouveau_gpuobj_new(struct nouveau_object *, struct nouveau_object *, - u32 size, u32 align, u32 flags, - struct nouveau_gpuobj **); -int nouveau_gpuobj_dup(struct nouveau_object *, struct nouveau_gpuobj *, - struct nouveau_gpuobj **); - -int nouveau_gpuobj_map(struct nouveau_gpuobj *, u32 acc, struct nouveau_vma *); -int nouveau_gpuobj_map_vm(struct nouveau_gpuobj *, struct nouveau_vm *, - u32 access, struct nouveau_vma *); -void nouveau_gpuobj_unmap(struct nouveau_vma *); +int nvkm_gpuobj_new(struct nvkm_object *, struct nvkm_object *, u32 size, + u32 align, u32 flags, struct nvkm_gpuobj **); +int nvkm_gpuobj_dup(struct nvkm_object *, struct nvkm_gpuobj *, + struct nvkm_gpuobj **); +int nvkm_gpuobj_map(struct nvkm_gpuobj *, u32 acc, struct nvkm_vma *); +int nvkm_gpuobj_map_vm(struct nvkm_gpuobj *, struct nvkm_vm *, u32 access, + struct nvkm_vma *); +void nvkm_gpuobj_unmap(struct nvkm_vma *); static inline void -nouveau_gpuobj_ref(struct nouveau_gpuobj *obj, struct nouveau_gpuobj **ref) +nvkm_gpuobj_ref(struct nvkm_gpuobj *obj, struct nvkm_gpuobj **ref) { - nouveau_object_ref(&obj->object, (struct nouveau_object **)ref); + nvkm_object_ref(&obj->object, (struct nvkm_object **)ref); } -void _nouveau_gpuobj_dtor(struct nouveau_object *); -int _nouveau_gpuobj_init(struct nouveau_object *); -int _nouveau_gpuobj_fini(struct nouveau_object *, bool); -u32 _nouveau_gpuobj_rd32(struct nouveau_object *, u64); -void _nouveau_gpuobj_wr32(struct nouveau_object *, u64, u32); - +void _nvkm_gpuobj_dtor(struct nvkm_object *); +int _nvkm_gpuobj_init(struct nvkm_object *); +int _nvkm_gpuobj_fini(struct nvkm_object *, bool); +u32 _nvkm_gpuobj_rd32(struct nvkm_object *, u64); +void _nvkm_gpuobj_wr32(struct nvkm_object *, u64, u32); #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/handle.h b/drivers/gpu/drm/nouveau/include/nvkm/core/handle.h index d22a591..67f384d 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/handle.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/handle.h @@ -1,8 +1,10 @@ -#ifndef __NOUVEAU_HANDLE_H__ -#define __NOUVEAU_HANDLE_H__ +#ifndef __NVKM_HANDLE_H__ +#define __NVKM_HANDLE_H__ +#include +struct nvkm_object; -struct nouveau_handle { - struct nouveau_namedb *namedb; +struct nvkm_handle { + struct nvkm_namedb *namedb; struct list_head node; struct list_head head; @@ -13,22 +15,20 @@ struct nouveau_handle { u8 route; u64 token; - struct nouveau_handle *parent; - struct nouveau_object *object; + struct nvkm_handle *parent; + struct nvkm_object *object; }; -int nouveau_handle_create(struct nouveau_object *, u32 parent, u32 handle, - struct nouveau_object *, struct nouveau_handle **); -void nouveau_handle_destroy(struct nouveau_handle *); -int nouveau_handle_init(struct nouveau_handle *); -int nouveau_handle_fini(struct nouveau_handle *, bool suspend); +int nvkm_handle_create(struct nvkm_object *, u32 parent, u32 handle, + struct nvkm_object *, struct nvkm_handle **); +void nvkm_handle_destroy(struct nvkm_handle *); +int nvkm_handle_init(struct nvkm_handle *); +int nvkm_handle_fini(struct nvkm_handle *, bool suspend); -struct nouveau_object * -nouveau_handle_ref(struct nouveau_object *, u32 name); - -struct nouveau_handle *nouveau_handle_get_class(struct nouveau_object *, u16); -struct nouveau_handle *nouveau_handle_get_vinst(struct nouveau_object *, u64); -struct nouveau_handle *nouveau_handle_get_cinst(struct nouveau_object *, u32); -void nouveau_handle_put(struct nouveau_handle *); +struct nvkm_object *nvkm_handle_ref(struct nvkm_object *, u32 name); +struct nvkm_handle *nvkm_handle_get_class(struct nvkm_object *, u16); +struct nvkm_handle *nvkm_handle_get_vinst(struct nvkm_object *, u64); +struct nvkm_handle *nvkm_handle_get_cinst(struct nvkm_object *, u32); +void nvkm_handle_put(struct nvkm_handle *); #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/ioctl.h b/drivers/gpu/drm/nouveau/include/nvkm/core/ioctl.h index ac7935c..88971eb 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/ioctl.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/ioctl.h @@ -1,6 +1,7 @@ #ifndef __NVKM_IOCTL_H__ #define __NVKM_IOCTL_H__ +#include +struct nvkm_client; -int nvkm_ioctl(struct nouveau_client *, bool, void *, u32, void **); - +int nvkm_ioctl(struct nvkm_client *, bool, void *, u32, void **); #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/mm.h b/drivers/gpu/drm/nouveau/include/nvkm/core/mm.h index bfe6931..096eb1a 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/mm.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/mm.h @@ -1,7 +1,8 @@ -#ifndef __NOUVEAU_MM_H__ -#define __NOUVEAU_MM_H__ +#ifndef __NVKM_MM_H__ +#define __NVKM_MM_H__ +#include -struct nouveau_mm_node { +struct nvkm_mm_node { struct list_head nl_entry; struct list_head fl_entry; struct list_head rl_entry; @@ -15,7 +16,7 @@ struct nouveau_mm_node { u32 length; }; -struct nouveau_mm { +struct nvkm_mm { struct list_head nodes; struct list_head free; @@ -24,17 +25,16 @@ struct nouveau_mm { }; static inline bool -nouveau_mm_initialised(struct nouveau_mm *mm) +nvkm_mm_initialised(struct nvkm_mm *mm) { return mm->block_size != 0; } -int nouveau_mm_init(struct nouveau_mm *, u32 offset, u32 length, u32 block); -int nouveau_mm_fini(struct nouveau_mm *); -int nouveau_mm_head(struct nouveau_mm *, u8 heap, u8 type, u32 size_max, - u32 size_min, u32 align, struct nouveau_mm_node **); -int nouveau_mm_tail(struct nouveau_mm *, u8 heap, u8 type, u32 size_max, - u32 size_min, u32 align, struct nouveau_mm_node **); -void nouveau_mm_free(struct nouveau_mm *, struct nouveau_mm_node **); - +int nvkm_mm_init(struct nvkm_mm *, u32 offset, u32 length, u32 block); +int nvkm_mm_fini(struct nvkm_mm *); +int nvkm_mm_head(struct nvkm_mm *, u8 heap, u8 type, u32 size_max, + u32 size_min, u32 align, struct nvkm_mm_node **); +int nvkm_mm_tail(struct nvkm_mm *, u8 heap, u8 type, u32 size_max, + u32 size_min, u32 align, struct nvkm_mm_node **); +void nvkm_mm_free(struct nvkm_mm *, struct nvkm_mm_node **); #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/namedb.h b/drivers/gpu/drm/nouveau/include/nvkm/core/namedb.h index 98e666b..4cfe16f 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/namedb.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/namedb.h @@ -1,17 +1,15 @@ -#ifndef __NOUVEAU_NAMEDB_H__ -#define __NOUVEAU_NAMEDB_H__ - +#ifndef __NVKM_NAMEDB_H__ +#define __NVKM_NAMEDB_H__ #include +struct nvkm_handle; -struct nouveau_handle; - -struct nouveau_namedb { - struct nouveau_parent parent; +struct nvkm_namedb { + struct nvkm_parent parent; rwlock_t lock; struct list_head list; }; -static inline struct nouveau_namedb * +static inline struct nvkm_namedb * nv_namedb(void *obj) { #if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA @@ -21,36 +19,35 @@ nv_namedb(void *obj) return obj; } -#define nouveau_namedb_create(p,e,c,v,s,m,d) \ - nouveau_namedb_create_((p), (e), (c), (v), (s), (m), \ +#define nvkm_namedb_create(p,e,c,v,s,m,d) \ + nvkm_namedb_create_((p), (e), (c), (v), (s), (m), \ sizeof(**d), (void **)d) -#define nouveau_namedb_init(p) \ - nouveau_parent_init(&(p)->parent) -#define nouveau_namedb_fini(p,s) \ - nouveau_parent_fini(&(p)->parent, (s)) -#define nouveau_namedb_destroy(p) \ - nouveau_parent_destroy(&(p)->parent) - -int nouveau_namedb_create_(struct nouveau_object *, struct nouveau_object *, - struct nouveau_oclass *, u32 pclass, - struct nouveau_oclass *, u64 engcls, +#define nvkm_namedb_init(p) \ + nvkm_parent_init(&(p)->parent) +#define nvkm_namedb_fini(p,s) \ + nvkm_parent_fini(&(p)->parent, (s)) +#define nvkm_namedb_destroy(p) \ + nvkm_parent_destroy(&(p)->parent) + +int nvkm_namedb_create_(struct nvkm_object *, struct nvkm_object *, + struct nvkm_oclass *, u32 pclass, + struct nvkm_oclass *, u64 engcls, int size, void **); -int _nouveau_namedb_ctor(struct nouveau_object *, struct nouveau_object *, - struct nouveau_oclass *, void *, u32, - struct nouveau_object **); -#define _nouveau_namedb_dtor _nouveau_parent_dtor -#define _nouveau_namedb_init _nouveau_parent_init -#define _nouveau_namedb_fini _nouveau_parent_fini - -int nouveau_namedb_insert(struct nouveau_namedb *, u32 name, - struct nouveau_object *, struct nouveau_handle *); -void nouveau_namedb_remove(struct nouveau_handle *); - -struct nouveau_handle *nouveau_namedb_get(struct nouveau_namedb *, u32); -struct nouveau_handle *nouveau_namedb_get_class(struct nouveau_namedb *, u16); -struct nouveau_handle *nouveau_namedb_get_vinst(struct nouveau_namedb *, u64); -struct nouveau_handle *nouveau_namedb_get_cinst(struct nouveau_namedb *, u32); -void nouveau_namedb_put(struct nouveau_handle *); - +int _nvkm_namedb_ctor(struct nvkm_object *, struct nvkm_object *, + struct nvkm_oclass *, void *, u32, + struct nvkm_object **); +#define _nvkm_namedb_dtor _nvkm_parent_dtor +#define _nvkm_namedb_init _nvkm_parent_init +#define _nvkm_namedb_fini _nvkm_parent_fini + +int nvkm_namedb_insert(struct nvkm_namedb *, u32 name, struct nvkm_object *, + struct nvkm_handle *); +void nvkm_namedb_remove(struct nvkm_handle *); + +struct nvkm_handle *nvkm_namedb_get(struct nvkm_namedb *, u32); +struct nvkm_handle *nvkm_namedb_get_class(struct nvkm_namedb *, u16); +struct nvkm_handle *nvkm_namedb_get_vinst(struct nvkm_namedb *, u64); +struct nvkm_handle *nvkm_namedb_get_cinst(struct nvkm_namedb *, u32); +void nvkm_namedb_put(struct nvkm_handle *); #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/notify.h b/drivers/gpu/drm/nouveau/include/nvkm/core/notify.h index a7c3c5f..753d08c 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/notify.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/notify.h @@ -1,5 +1,7 @@ #ifndef __NVKM_NOTIFY_H__ #define __NVKM_NOTIFY_H__ +#include +struct nvkm_object; struct nvkm_notify { struct nvkm_event *event; @@ -25,7 +27,7 @@ struct nvkm_notify { const void *data; }; -int nvkm_notify_init(struct nouveau_object *, struct nvkm_event *, +int nvkm_notify_init(struct nvkm_object *, struct nvkm_event *, int (*func)(struct nvkm_notify *), bool work, void *data, u32 size, u32 reply, struct nvkm_notify *); @@ -33,5 +35,4 @@ void nvkm_notify_fini(struct nvkm_notify *); void nvkm_notify_get(struct nvkm_notify *); void nvkm_notify_put(struct nvkm_notify *); void nvkm_notify_send(struct nvkm_notify *, void *data, u32 size); - #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/object.h b/drivers/gpu/drm/nouveau/include/nvkm/core/object.h index 64c0038..6e3cd39 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/object.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/object.h @@ -1,6 +1,5 @@ -#ifndef __NOUVEAU_OBJECT_H__ -#define __NOUVEAU_OBJECT_H__ - +#ifndef __NVKM_OBJECT_H__ +#define __NVKM_OBJECT_H__ #include #include @@ -14,52 +13,52 @@ #define NV_ENGCTX_CLASS 0x01000000 #define NV_OBJECT_CLASS 0x0000ffff -struct nouveau_object { - struct nouveau_oclass *oclass; - struct nouveau_object *parent; - struct nouveau_engine *engine; +struct nvkm_object { + struct nvkm_oclass *oclass; + struct nvkm_object *parent; + struct nvkm_engine *engine; atomic_t refcount; atomic_t usecount; #if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA -#define NOUVEAU_OBJECT_MAGIC 0x75ef0bad +#define NVKM_OBJECT_MAGIC 0x75ef0bad struct list_head list; u32 _magic; #endif }; -static inline struct nouveau_object * +static inline struct nvkm_object * nv_object(void *obj) { #if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA if (likely(obj)) { - struct nouveau_object *object = obj; - if (unlikely(object->_magic != NOUVEAU_OBJECT_MAGIC)) + struct nvkm_object *object = obj; + if (unlikely(object->_magic != NVKM_OBJECT_MAGIC)) nv_assert("BAD CAST -> NvObject, invalid magic"); } #endif return obj; } -#define nouveau_object_create(p,e,c,s,d) \ - nouveau_object_create_((p), (e), (c), (s), sizeof(**d), (void **)d) -int nouveau_object_create_(struct nouveau_object *, struct nouveau_object *, - struct nouveau_oclass *, u32, int size, void **); -void nouveau_object_destroy(struct nouveau_object *); -int nouveau_object_init(struct nouveau_object *); -int nouveau_object_fini(struct nouveau_object *, bool suspend); +#define nvkm_object_create(p,e,c,s,d) \ + nvkm_object_create_((p), (e), (c), (s), sizeof(**d), (void **)d) +int nvkm_object_create_(struct nvkm_object *, struct nvkm_object *, + struct nvkm_oclass *, u32, int size, void **); +void nvkm_object_destroy(struct nvkm_object *); +int nvkm_object_init(struct nvkm_object *); +int nvkm_object_fini(struct nvkm_object *, bool suspend); -int _nouveau_object_ctor(struct nouveau_object *, struct nouveau_object *, - struct nouveau_oclass *, void *, u32, - struct nouveau_object **); +int _nvkm_object_ctor(struct nvkm_object *, struct nvkm_object *, + struct nvkm_oclass *, void *, u32, + struct nvkm_object **); -extern struct nouveau_ofuncs nouveau_object_ofuncs; +extern struct nvkm_ofuncs nvkm_object_ofuncs; /* Don't allocate dynamically, because lockdep needs lock_class_keys to be in * ".data". */ -struct nouveau_oclass { +struct nvkm_oclass { u32 handle; - struct nouveau_ofuncs * const ofuncs; - struct nouveau_omthds * const omthds; + struct nvkm_ofuncs * const ofuncs; + struct nvkm_omthds * const omthds; struct lock_class_key lock_class_key; }; @@ -68,58 +67,57 @@ struct nouveau_oclass { #define nv_iclass(o,i) (nv_hclass(o) & (i)) #define nv_mclass(o) nv_iclass(o, NV_OBJECT_CLASS) -static inline struct nouveau_object * -nv_pclass(struct nouveau_object *parent, u32 oclass) +static inline struct nvkm_object * +nv_pclass(struct nvkm_object *parent, u32 oclass) { while (parent && !nv_iclass(parent, oclass)) parent = parent->parent; return parent; } -struct nouveau_omthds { +struct nvkm_omthds { u32 start; u32 limit; - int (*call)(struct nouveau_object *, u32, void *, u32); + int (*call)(struct nvkm_object *, u32, void *, u32); }; struct nvkm_event; -struct nouveau_ofuncs { - int (*ctor)(struct nouveau_object *, struct nouveau_object *, - struct nouveau_oclass *, void *data, u32 size, - struct nouveau_object **); - void (*dtor)(struct nouveau_object *); - int (*init)(struct nouveau_object *); - int (*fini)(struct nouveau_object *, bool suspend); - int (*mthd)(struct nouveau_object *, u32, void *, u32); - int (*ntfy)(struct nouveau_object *, u32, struct nvkm_event **); - int (* map)(struct nouveau_object *, u64 *, u32 *); - u8 (*rd08)(struct nouveau_object *, u64 offset); - u16 (*rd16)(struct nouveau_object *, u64 offset); - u32 (*rd32)(struct nouveau_object *, u64 offset); - void (*wr08)(struct nouveau_object *, u64 offset, u8 data); - void (*wr16)(struct nouveau_object *, u64 offset, u16 data); - void (*wr32)(struct nouveau_object *, u64 offset, u32 data); +struct nvkm_ofuncs { + int (*ctor)(struct nvkm_object *, struct nvkm_object *, + struct nvkm_oclass *, void *data, u32 size, + struct nvkm_object **); + void (*dtor)(struct nvkm_object *); + int (*init)(struct nvkm_object *); + int (*fini)(struct nvkm_object *, bool suspend); + int (*mthd)(struct nvkm_object *, u32, void *, u32); + int (*ntfy)(struct nvkm_object *, u32, struct nvkm_event **); + int (* map)(struct nvkm_object *, u64 *, u32 *); + u8 (*rd08)(struct nvkm_object *, u64 offset); + u16 (*rd16)(struct nvkm_object *, u64 offset); + u32 (*rd32)(struct nvkm_object *, u64 offset); + void (*wr08)(struct nvkm_object *, u64 offset, u8 data); + void (*wr16)(struct nvkm_object *, u64 offset, u16 data); + void (*wr32)(struct nvkm_object *, u64 offset, u32 data); }; -static inline struct nouveau_ofuncs * +static inline struct nvkm_ofuncs * nv_ofuncs(void *obj) { return nv_oclass(obj)->ofuncs; } -int nouveau_object_ctor(struct nouveau_object *, struct nouveau_object *, - struct nouveau_oclass *, void *, u32, - struct nouveau_object **); -void nouveau_object_ref(struct nouveau_object *, struct nouveau_object **); -int nouveau_object_inc(struct nouveau_object *); -int nouveau_object_dec(struct nouveau_object *, bool suspend); - -void nouveau_object_debug(void); +int nvkm_object_ctor(struct nvkm_object *, struct nvkm_object *, + struct nvkm_oclass *, void *, u32, + struct nvkm_object **); +void nvkm_object_ref(struct nvkm_object *, struct nvkm_object **); +int nvkm_object_inc(struct nvkm_object *); +int nvkm_object_dec(struct nvkm_object *, bool suspend); +void nvkm_object_debug(void); static inline int nv_exec(void *obj, u32 mthd, void *data, u32 size) { - struct nouveau_omthds *method = nv_oclass(obj)->omthds; + struct nvkm_omthds *method = nv_oclass(obj)->omthds; while (method && method->call) { if (mthd >= method->start && mthd <= method->limit) @@ -202,5 +200,4 @@ nv_memcmp(void *obj, u32 addr, const char *str, u32 len) } return 0; } - #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/option.h b/drivers/gpu/drm/nouveau/include/nvkm/core/option.h index ed05584..532bfa8 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/option.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/option.h @@ -1,12 +1,10 @@ -#ifndef __NOUVEAU_OPTION_H__ -#define __NOUVEAU_OPTION_H__ - +#ifndef __NVKM_OPTION_H__ +#define __NVKM_OPTION_H__ #include -const char *nouveau_stropt(const char *optstr, const char *opt, int *len); -bool nouveau_boolopt(const char *optstr, const char *opt, bool value); - -int nouveau_dbgopt(const char *optstr, const char *sub); +const char *nvkm_stropt(const char *optstr, const char *opt, int *len); +bool nvkm_boolopt(const char *optstr, const char *opt, bool value); +int nvkm_dbgopt(const char *optstr, const char *sub); /* compares unterminated string 'str' with zero-terminated string 'cmp' */ static inline int @@ -16,5 +14,4 @@ strncasecmpz(const char *str, const char *cmp, size_t len) return len; return strncasecmp(str, cmp, len); } - #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/os.h b/drivers/gpu/drm/nouveau/include/nvkm/core/os.h index cd57e23..0b5a1e4 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/os.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/os.h @@ -1,4 +1,195 @@ #ifndef __NVKM_OS_H__ #define __NVKM_OS_H__ #include + +#define nouveau_client nvkm_client +#define nouveau_client_name nvkm_client_name +#define nouveau_client_create nvkm_client_create +#define nouveau_client_init nvkm_client_init +#define nouveau_client_fini nvkm_client_fini +#define nouveau_engctx nvkm_engctx +#define nouveau_engctx_create nvkm_engctx_create +#define nouveau_engctx_create_ nvkm_engctx_create_ +#define nouveau_engctx_destroy nvkm_engctx_destroy +#define nouveau_engctx_init nvkm_engctx_init +#define nouveau_engctx_fini nvkm_engctx_fini +#define _nouveau_engctx_ctor _nvkm_engctx_ctor +#define _nouveau_engctx_dtor _nvkm_engctx_dtor +#define _nouveau_engctx_init _nvkm_engctx_init +#define _nouveau_engctx_fini _nvkm_engctx_fini +#define _nouveau_engctx_rd32 _nvkm_engctx_rd32 +#define _nouveau_engctx_wr32 _nvkm_engctx_wr32 +#define nouveau_engctx_get nvkm_engctx_get +#define nouveau_engctx_put nvkm_engctx_put +#define nouveau_engine nvkm_engine +#define nouveau_engine_create nvkm_engine_create +#define nouveau_engine_create_ nvkm_engine_create_ +#define nouveau_engine_destroy nvkm_engine_destroy +#define nouveau_engine_init nvkm_engine_init +#define nouveau_engine_fini nvkm_engine_fini +#define _nouveau_engine_ctor _nvkm_engine_ctor +#define _nouveau_engine_dtor _nvkm_engine_dtor +#define _nouveau_engine_init _nvkm_engine_init +#define _nouveau_engine_fini _nvkm_engine_fini +#define nouveau_enum nvkm_enum +#define nouveau_gpuobj nvkm_gpuobj +#define nouveau_gpuobj_create nvkm_gpuobj_create +#define nouveau_gpuobj_destroy nvkm_gpuobj_destroy +#define _nouveau_gpuobj_ctor _nvkm_gpuobj_ctor +#define _nouveau_gpuobj_dtor _nvkm_gpuobj_dtor +#define _nouveau_gpuobj_init _nvkm_gpuobj_init +#define _nouveau_gpuobj_fini _nvkm_gpuobj_fini +#define _nouveau_gpuobj_rd32 _nvkm_gpuobj_rd32 +#define _nouveau_gpuobj_wr32 _nvkm_gpuobj_wr32 +#define nouveau_gpuobj_new nvkm_gpuobj_new +#define nouveau_gpuobj_dup nvkm_gpuobj_dup +#define nouveau_gpuobj_ref nvkm_gpuobj_ref +#define nouveau_gpuobj_map nvkm_gpuobj_map +#define nouveau_gpuobj_map_vm nvkm_gpuobj_map_vm +#define nouveau_gpuobj_unmap nvkm_gpuobj_unmap +#define nouveau_handle nvkm_handle +#define nouveau_handle_ref nvkm_handle_ref +#define nouveau_handle_put nvkm_handle_put +#define nouveau_handle_get_class nvkm_handle_get_class +#define nouveau_handle_get_vinst nvkm_handle_get_vinst +#define nouveau_handle_get_cinst nvkm_handle_get_cinst +#define nouveau_mm nvkm_mm +#define nouveau_mm_node nvkm_mm_node +#define nouveau_mm_init nvkm_mm_init +#define nouveau_mm_fini nvkm_mm_fini +#define nouveau_mm_head nvkm_mm_head +#define nouveau_mm_tail nvkm_mm_tail +#define nouveau_mm_free nvkm_mm_free +#define nouveau_mm_initialised nvkm_mm_initialised +#define nouveau_namedb nvkm_namedb +#define nouveau_namedb_create nvkm_namedb_create +#define nouveau_namedb_create_ nvkm_namedb_create_ +#define nouveau_namedb_destroy nvkm_namedb_destroy +#define nouveau_namedb_init nvkm_namedb_init +#define nouveau_namedb_fini nvkm_namedb_fini +#define _nouveau_namedb_ctor _nvkm_namedb_ctor +#define _nouveau_namedb_dtor _nvkm_namedb_dtor +#define _nouveau_namedb_init _nvkm_namedb_init +#define _nouveau_namedb_fini _nvkm_namedb_fini +#define nouveau_namedb_ref nvkm_namedb_ref +#define nouveau_namedb_put nvkm_namedb_put +#define nouveau_namedb_get nvkm_namedb_get +#define nouveau_namedb_get_class nvkm_namedb_get_class +#define nouveau_namedb_get_vinst nvkm_namedb_get_vinst +#define nouveau_namedb_get_cinst nvkm_namedb_get_cinst +#define nouveau_object_debug nvkm_object_debug +#define nouveau_object nvkm_object +#define nouveau_object_create nvkm_object_create +#define nouveau_object_create_ nvkm_object_create_ +#define nouveau_object_destroy nvkm_object_destroy +#define nouveau_object_init nvkm_object_init +#define nouveau_object_fini nvkm_object_fini +#define _nouveau_object_ctor _nvkm_object_ctor +#define nouveau_object_ctor nvkm_object_ctor +#define nouveau_object_ref nvkm_object_ref +#define nouveau_object_ofuncs nvkm_object_ofuncs +#define nouveau_object_inc nvkm_object_inc +#define nouveau_object_dec nvkm_object_dec +#define nouveau_ofuncs nvkm_ofuncs +#define nouveau_oclass nvkm_oclass +#define nouveau_omthds nvkm_omthds +#define nouveau_parent nvkm_parent +#define nouveau_parent_create nvkm_parent_create +#define nouveau_parent_create_ nvkm_parent_create_ +#define nouveau_parent_destroy nvkm_parent_destroy +#define nouveau_parent_init nvkm_parent_init +#define nouveau_parent_fini nvkm_parent_fini +#define _nouveau_parent_ctor _nvkm_parent_ctor +#define _nouveau_parent_dtor _nvkm_parent_dtor +#define _nouveau_parent_init _nvkm_parent_init +#define _nouveau_parent_fini _nvkm_parent_fini +#define nouveau_printk nvkm_printk +#define nouveau_ramht nvkm_ramht +#define nouveau_ramht_new nvkm_ramht_new +#define nouveau_ramht_ref nvkm_ramht_ref +#define nouveau_ramht_insert nvkm_ramht_insert +#define nouveau_ramht_remove nvkm_ramht_remove +#define nouveau_subdev nvkm_subdev +#define nouveau_subdev_create nvkm_subdev_create +#define nouveau_subdev_create_ nvkm_subdev_create_ +#define nouveau_subdev_destroy nvkm_subdev_destroy +#define nouveau_subdev_init nvkm_subdev_init +#define nouveau_subdev_fini nvkm_subdev_fini +#define _nouveau_subdev_ctor _nvkm_subdev_ctor +#define _nouveau_subdev_dtor _nvkm_subdev_dtor +#define _nouveau_subdev_init _nvkm_subdev_init +#define _nouveau_subdev_fini _nvkm_subdev_fini +#define nouveau_subdev_reset nvkm_subdev_reset +#define nouveau_bitfield nvkm_bitfield +#define nouveau_bitfield_print nvkm_bitfield_print +#define nouveau_enum nvkm_enum +#define nouveau_enum_find nvkm_enum_find +#define nouveau_enum_print nvkm_enum_print +#define nouveau_stropt nvkm_stropt +#define nouveau_boolopt nvkm_boolopt +#define nouveau_dbgopt nvkm_dbgopt +#define nouveau_device nvkm_device +#define nouveau_device_find nvkm_device_find +#define nouveau_device_list nvkm_device_list +#define nouveau_vma nvkm_vma +#define nouveau_vm nvkm_vm +#define nouveau_vm_get nvkm_vm_get +#define nouveau_vm_put nvkm_vm_put +#define nouveau_vm_map nvkm_vm_map +#define nouveau_vm_unmap nvkm_vm_unmap +#define nouveau_instmem nvkm_instmem +#define nouveau_instobj nvkm_instobj +#define nouveau_mem nvkm_mem +#define nouveau_bar nvkm_bar +#define nouveau_falcon nvkm_falcon +#define nouveau_falcon_create nvkm_falcon_create +#define nouveau_falcon_create_ nvkm_falcon_create_ +#define nouveau_falcon_destroy nvkm_falcon_destroy +#define nouveau_falcon_init nvkm_falcon_init +#define nouveau_falcon_fini nvkm_falcon_fini +#define _nouveau_falcon_ctor _nvkm_falcon_ctor +#define _nouveau_falcon_dtor _nvkm_falcon_dtor +#define _nouveau_falcon_init _nvkm_falcon_init +#define _nouveau_falcon_fini _nvkm_falcon_fini +#define _nouveau_falcon_rd32 _nvkm_falcon_rd32 +#define _nouveau_falcon_wr32 _nvkm_falcon_wr32 +#define nouveau_falcon_context nvkm_falcon_context +#define nouveau_falcon_context_create nvkm_falcon_context_create +#define nouveau_falcon_context_create_ nvkm_falcon_context_create_ +#define nouveau_falcon_context_destroy nvkm_falcon_context_destroy +#define nouveau_falcon_context_init nvkm_falcon_context_init +#define nouveau_falcon_context_fini nvkm_falcon_context_fini +#define _nouveau_falcon_context_ctor _nvkm_falcon_context_ctor +#define _nouveau_falcon_context_dtor _nvkm_falcon_context_dtor +#define _nouveau_falcon_context_init _nvkm_falcon_context_init +#define _nouveau_falcon_context_fini _nvkm_falcon_context_fini +#define _nouveau_falcon_context_rd32 _nvkm_falcon_context_rd32 +#define _nouveau_falcon_context_wr32 _nvkm_falcon_context_wr32 +#define nouveau_falcon_intr nvkm_falcon_intr +#define nouveau_xtensa nvkm_xtensa +#define nouveau_xtensa_create nvkm_xtensa_create +#define nouveau_xtensa_create_ nvkm_xtensa_create_ +#define nouveau_xtensa_destroy nvkm_xtensa_destroy +#define nouveau_xtensa_init nvkm_xtensa_init +#define nouveau_xtensa_fini nvkm_xtensa_fini +#define _nouveau_xtensa_ctor _nvkm_xtensa_ctor +#define _nouveau_xtensa_dtor _nvkm_xtensa_dtor +#define _nouveau_xtensa_init _nvkm_xtensa_init +#define _nouveau_xtensa_fini _nvkm_xtensa_fini +#define _nouveau_xtensa_rd32 _nvkm_xtensa_rd32 +#define _nouveau_xtensa_wr32 _nvkm_xtensa_wr32 +#define nouveau_xtensa_context nvkm_xtensa_context +#define nouveau_xtensa_context_create nvkm_xtensa_context_create +#define nouveau_xtensa_context_create_ nvkm_xtensa_context_create_ +#define nouveau_xtensa_context_destroy nvkm_xtensa_context_destroy +#define nouveau_xtensa_context_init nvkm_xtensa_context_init +#define nouveau_xtensa_context_fini nvkm_xtensa_context_fini +#define _nouveau_xtensa_engctx_ctor _nvkm_xtensa_engctx_ctor +#define _nouveau_xtensa_context_dtor _nvkm_xtensa_context_dtor +#define _nouveau_xtensa_context_init _nvkm_xtensa_context_init +#define _nouveau_xtensa_context_fini _nvkm_xtensa_context_fini +#define _nouveau_xtensa_context_rd32 _nvkm_xtensa_context_rd32 +#define _nouveau_xtensa_context_wr32 _nvkm_xtensa_context_wr32 +#define nouveau_xtensa_intr nvkm_xtensa_intr + #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/parent.h b/drivers/gpu/drm/nouveau/include/nvkm/core/parent.h index 4e2345a..837e4fe 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/parent.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/parent.h @@ -1,32 +1,29 @@ -#ifndef __NOUVEAU_PARENT_H__ -#define __NOUVEAU_PARENT_H__ - -#include +#ifndef __NVKM_PARENT_H__ +#define __NVKM_PARENT_H__ #include -struct nouveau_sclass { - struct nouveau_sclass *sclass; - struct nouveau_engine *engine; - struct nouveau_oclass *oclass; +struct nvkm_sclass { + struct nvkm_sclass *sclass; + struct nvkm_engine *engine; + struct nvkm_oclass *oclass; }; -struct nouveau_parent { - struct nouveau_object object; +struct nvkm_parent { + struct nvkm_object object; - struct nouveau_sclass *sclass; + struct nvkm_sclass *sclass; u64 engine; - int (*context_attach)(struct nouveau_object *, - struct nouveau_object *); - int (*context_detach)(struct nouveau_object *, bool suspend, - struct nouveau_object *); + int (*context_attach)(struct nvkm_object *, struct nvkm_object *); + int (*context_detach)(struct nvkm_object *, bool suspend, + struct nvkm_object *); - int (*object_attach)(struct nouveau_object *parent, - struct nouveau_object *object, u32 name); - void (*object_detach)(struct nouveau_object *parent, int cookie); + int (*object_attach)(struct nvkm_object *parent, + struct nvkm_object *object, u32 name); + void (*object_detach)(struct nvkm_object *parent, int cookie); }; -static inline struct nouveau_parent * +static inline struct nvkm_parent * nv_parent(void *obj) { #if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA @@ -36,27 +33,26 @@ nv_parent(void *obj) return obj; } -#define nouveau_parent_create(p,e,c,v,s,m,d) \ - nouveau_parent_create_((p), (e), (c), (v), (s), (m), \ +#define nvkm_parent_create(p,e,c,v,s,m,d) \ + nvkm_parent_create_((p), (e), (c), (v), (s), (m), \ sizeof(**d), (void **)d) -#define nouveau_parent_init(p) \ - nouveau_object_init(&(p)->object) -#define nouveau_parent_fini(p,s) \ - nouveau_object_fini(&(p)->object, (s)) - -int nouveau_parent_create_(struct nouveau_object *, struct nouveau_object *, - struct nouveau_oclass *, u32 pclass, - struct nouveau_oclass *, u64 engcls, +#define nvkm_parent_init(p) \ + nvkm_object_init(&(p)->object) +#define nvkm_parent_fini(p,s) \ + nvkm_object_fini(&(p)->object, (s)) + +int nvkm_parent_create_(struct nvkm_object *, struct nvkm_object *, + struct nvkm_oclass *, u32 pclass, + struct nvkm_oclass *, u64 engcls, int size, void **); -void nouveau_parent_destroy(struct nouveau_parent *); - -void _nouveau_parent_dtor(struct nouveau_object *); -#define _nouveau_parent_init nouveau_object_init -#define _nouveau_parent_fini nouveau_object_fini +void nvkm_parent_destroy(struct nvkm_parent *); -int nouveau_parent_sclass(struct nouveau_object *, u16 handle, - struct nouveau_object **pengine, - struct nouveau_oclass **poclass); -int nouveau_parent_lclass(struct nouveau_object *, u32 *, int); +void _nvkm_parent_dtor(struct nvkm_object *); +#define _nvkm_parent_init nvkm_object_init +#define _nvkm_parent_fini nvkm_object_fini +int nvkm_parent_sclass(struct nvkm_object *, u16 handle, + struct nvkm_object **pengine, + struct nvkm_oclass **poclass); +int nvkm_parent_lclass(struct nvkm_object *, u32 *, int); #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/printk.h b/drivers/gpu/drm/nouveau/include/nvkm/core/printk.h index 451b6ed..8364817 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/printk.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/printk.h @@ -1,13 +1,11 @@ -#ifndef __NOUVEAU_PRINTK_H__ -#define __NOUVEAU_PRINTK_H__ - +#ifndef __NVKM_PRINTK_H__ +#define __NVKM_PRINTK_H__ #include #include - -struct nouveau_object; +struct nvkm_object; void __printf(3, 4) -nv_printk_(struct nouveau_object *, int, const char *, ...); +nv_printk_(struct nvkm_object *, int, const char *, ...); #define nv_printk(o,l,f,a...) do { \ if (NV_DBG_##l <= CONFIG_NOUVEAU_DEBUG) \ @@ -21,12 +19,11 @@ nv_printk_(struct nouveau_object *, int, const char *, ...); #define nv_debug(o,f,a...) nv_printk((o), DEBUG, f, ##a) #define nv_trace(o,f,a...) nv_printk((o), TRACE, f, ##a) #define nv_spam(o,f,a...) nv_printk((o), SPAM, f, ##a) -#define nv_ioctl(o,f,a...) nv_trace(nouveau_client(o), "ioctl: "f, ##a) +#define nv_ioctl(o,f,a...) nv_trace(nvkm_client(o), "ioctl: "f, ##a) #define nv_assert(f,a...) do { \ if (NV_DBG_FATAL <= CONFIG_NOUVEAU_DEBUG) \ nv_printk_(NULL, NV_DBG_FATAL, f "\n", ##a); \ BUG_ON(1); \ } while(0) - #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/ramht.h b/drivers/gpu/drm/nouveau/include/nvkm/core/ramht.h index e510143..cc132ea 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/ramht.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/ramht.h @@ -1,23 +1,20 @@ -#ifndef __NOUVEAU_RAMHT_H__ -#define __NOUVEAU_RAMHT_H__ - +#ifndef __NVKM_RAMHT_H__ +#define __NVKM_RAMHT_H__ #include -struct nouveau_ramht { - struct nouveau_gpuobj gpuobj; +struct nvkm_ramht { + struct nvkm_gpuobj gpuobj; int bits; }; -int nouveau_ramht_insert(struct nouveau_ramht *, int chid, - u32 handle, u32 context); -void nouveau_ramht_remove(struct nouveau_ramht *, int cookie); -int nouveau_ramht_new(struct nouveau_object *, struct nouveau_object *, - u32 size, u32 align, struct nouveau_ramht **); +int nvkm_ramht_insert(struct nvkm_ramht *, int chid, u32 handle, u32 context); +void nvkm_ramht_remove(struct nvkm_ramht *, int cookie); +int nvkm_ramht_new(struct nvkm_object *, struct nvkm_object *, u32 size, + u32 align, struct nvkm_ramht **); static inline void -nouveau_ramht_ref(struct nouveau_ramht *obj, struct nouveau_ramht **ref) +nvkm_ramht_ref(struct nvkm_ramht *obj, struct nvkm_ramht **ref) { - nouveau_gpuobj_ref(&obj->gpuobj, (struct nouveau_gpuobj **)ref); + nvkm_gpuobj_ref(&obj->gpuobj, (struct nvkm_gpuobj **)ref); } - #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/subdev.h b/drivers/gpu/drm/nouveau/include/nvkm/core/subdev.h index 152c842..6fdc391 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/core/subdev.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/core/subdev.h @@ -1,24 +1,23 @@ -#ifndef __NOUVEAU_SUBDEV_H__ -#define __NOUVEAU_SUBDEV_H__ - +#ifndef __NVKM_SUBDEV_H__ +#define __NVKM_SUBDEV_H__ #include #include #define NV_SUBDEV_(sub,var) (NV_SUBDEV_CLASS | ((var) << 8) | (sub)) #define NV_SUBDEV(name,var) NV_SUBDEV_(NVDEV_SUBDEV_##name, (var)) -struct nouveau_subdev { - struct nouveau_object object; +struct nvkm_subdev { + struct nvkm_object object; struct mutex mutex; const char *name; void __iomem *mmio; u32 debug; u32 unit; - void (*intr)(struct nouveau_subdev *); + void (*intr)(struct nvkm_subdev *); }; -static inline struct nouveau_subdev * +static inline struct nvkm_subdev * nv_subdev(void *obj) { #if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA @@ -29,29 +28,29 @@ nv_subdev(void *obj) } static inline int -nv_subidx(struct nouveau_subdev *subdev) +nv_subidx(struct nvkm_subdev *subdev) { return nv_hclass(subdev) & 0xff; } -struct nouveau_subdev *nouveau_subdev(void *obj, int idx); +struct nvkm_subdev *nvkm_subdev(void *obj, int idx); -#define nouveau_subdev_create(p,e,o,v,s,f,d) \ - nouveau_subdev_create_((p), (e), (o), (v), (s), (f), \ +#define nvkm_subdev_create(p,e,o,v,s,f,d) \ + nvkm_subdev_create_((p), (e), (o), (v), (s), (f), \ sizeof(**d),(void **)d) -int nouveau_subdev_create_(struct nouveau_object *, struct nouveau_object *, - struct nouveau_oclass *, u32 pclass, +int nvkm_subdev_create_(struct nvkm_object *, struct nvkm_object *, + struct nvkm_oclass *, u32 pclass, const char *sname, const char *fname, int size, void **); -void nouveau_subdev_destroy(struct nouveau_subdev *); -int nouveau_subdev_init(struct nouveau_subdev *); -int nouveau_subdev_fini(struct nouveau_subdev *, bool suspend); -void nouveau_subdev_reset(struct nouveau_object *); +void nvkm_subdev_destroy(struct nvkm_subdev *); +int nvkm_subdev_init(struct nvkm_subdev *); +int nvkm_subdev_fini(struct nvkm_subdev *, bool suspend); +void nvkm_subdev_reset(struct nvkm_object *); -void _nouveau_subdev_dtor(struct nouveau_object *); -int _nouveau_subdev_init(struct nouveau_object *); -int _nouveau_subdev_fini(struct nouveau_object *, bool suspend); +void _nvkm_subdev_dtor(struct nvkm_object *); +int _nvkm_subdev_init(struct nvkm_object *); +int _nvkm_subdev_fini(struct nvkm_object *, bool suspend); #define s_printk(s,l,f,a...) do { \ if ((s)->debug >= OS_DBG_##l) { \ @@ -62,7 +61,7 @@ int _nouveau_subdev_fini(struct nouveau_object *, bool suspend); static inline u8 nv_rd08(void *obj, u32 addr) { - struct nouveau_subdev *subdev = nv_subdev(obj); + struct nvkm_subdev *subdev = nv_subdev(obj); u8 data = ioread8(subdev->mmio + addr); nv_spam(subdev, "nv_rd08 0x%06x 0x%02x\n", addr, data); return data; @@ -71,7 +70,7 @@ nv_rd08(void *obj, u32 addr) static inline u16 nv_rd16(void *obj, u32 addr) { - struct nouveau_subdev *subdev = nv_subdev(obj); + struct nvkm_subdev *subdev = nv_subdev(obj); u16 data = ioread16_native(subdev->mmio + addr); nv_spam(subdev, "nv_rd16 0x%06x 0x%04x\n", addr, data); return data; @@ -80,7 +79,7 @@ nv_rd16(void *obj, u32 addr) static inline u32 nv_rd32(void *obj, u32 addr) { - struct nouveau_subdev *subdev = nv_subdev(obj); + struct nvkm_subdev *subdev = nv_subdev(obj); u32 data = ioread32_native(subdev->mmio + addr); nv_spam(subdev, "nv_rd32 0x%06x 0x%08x\n", addr, data); return data; @@ -89,7 +88,7 @@ nv_rd32(void *obj, u32 addr) static inline void nv_wr08(void *obj, u32 addr, u8 data) { - struct nouveau_subdev *subdev = nv_subdev(obj); + struct nvkm_subdev *subdev = nv_subdev(obj); nv_spam(subdev, "nv_wr08 0x%06x 0x%02x\n", addr, data); iowrite8(data, subdev->mmio + addr); } @@ -97,7 +96,7 @@ nv_wr08(void *obj, u32 addr, u8 data) static inline void nv_wr16(void *obj, u32 addr, u16 data) { - struct nouveau_subdev *subdev = nv_subdev(obj); + struct nvkm_subdev *subdev = nv_subdev(obj); nv_spam(subdev, "nv_wr16 0x%06x 0x%04x\n", addr, data); iowrite16_native(data, subdev->mmio + addr); } @@ -105,7 +104,7 @@ nv_wr16(void *obj, u32 addr, u16 data) static inline void nv_wr32(void *obj, u32 addr, u32 data) { - struct nouveau_subdev *subdev = nv_subdev(obj); + struct nvkm_subdev *subdev = nv_subdev(obj); nv_spam(subdev, "nv_wr32 0x%06x 0x%08x\n", addr, data); iowrite32_native(data, subdev->mmio + addr); } @@ -117,5 +116,4 @@ nv_mask(void *obj, u32 addr, u32 mask, u32 data) nv_wr32(obj, addr, (temp & ~mask) | data); return temp; } - #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/engine/device.h b/drivers/gpu/drm/nouveau/include/nvkm/engine/device.h index 672d3c8..5d4805e 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/engine/device.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/engine/device.h @@ -27,7 +27,4 @@ int nv50_identify(struct nouveau_device *); int nvc0_identify(struct nouveau_device *); int nve0_identify(struct nouveau_device *); int gm100_identify(struct nouveau_device *); - -struct nouveau_device *nouveau_device_find(u64 name); - #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/engine/falcon.h b/drivers/gpu/drm/nouveau/include/nvkm/engine/falcon.h index 181aa7d..bd38cf9 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/engine/falcon.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/engine/falcon.h @@ -1,42 +1,41 @@ -#ifndef __NOUVEAU_FALCON_H__ -#define __NOUVEAU_FALCON_H__ - -#include +#ifndef __NVKM_FALCON_H__ +#define __NVKM_FALCON_H__ #include -#include -struct nouveau_falcon_chan { - struct nouveau_engctx base; +struct nvkm_falcon_chan { + struct nvkm_engctx base; }; -#define nouveau_falcon_context_create(p,e,c,g,s,a,f,d) \ - nouveau_engctx_create((p), (e), (c), (g), (s), (a), (f), (d)) -#define nouveau_falcon_context_destroy(d) \ - nouveau_engctx_destroy(&(d)->base) -#define nouveau_falcon_context_init(d) \ - nouveau_engctx_init(&(d)->base) -#define nouveau_falcon_context_fini(d,s) \ - nouveau_engctx_fini(&(d)->base, (s)) - -#define _nouveau_falcon_context_ctor _nouveau_engctx_ctor -#define _nouveau_falcon_context_dtor _nouveau_engctx_dtor -#define _nouveau_falcon_context_init _nouveau_engctx_init -#define _nouveau_falcon_context_fini _nouveau_engctx_fini -#define _nouveau_falcon_context_rd32 _nouveau_engctx_rd32 -#define _nouveau_falcon_context_wr32 _nouveau_engctx_wr32 - -struct nouveau_falcon_data { +#define nvkm_falcon_context_create(p,e,c,g,s,a,f,d) \ + nvkm_engctx_create((p), (e), (c), (g), (s), (a), (f), (d)) +#define nvkm_falcon_context_destroy(d) \ + nvkm_engctx_destroy(&(d)->base) +#define nvkm_falcon_context_init(d) \ + nvkm_engctx_init(&(d)->base) +#define nvkm_falcon_context_fini(d,s) \ + nvkm_engctx_fini(&(d)->base, (s)) + +#define _nvkm_falcon_context_ctor _nvkm_engctx_ctor +#define _nvkm_falcon_context_dtor _nvkm_engctx_dtor +#define _nvkm_falcon_context_init _nvkm_engctx_init +#define _nvkm_falcon_context_fini _nvkm_engctx_fini +#define _nvkm_falcon_context_rd32 _nvkm_engctx_rd32 +#define _nvkm_falcon_context_wr32 _nvkm_engctx_wr32 + +struct nvkm_falcon_data { bool external; }; -struct nouveau_falcon { - struct nouveau_engine base; +#include + +struct nvkm_falcon { + struct nvkm_engine base; u32 addr; u8 version; u8 secret; - struct nouveau_gpuobj *core; + struct nvkm_gpuobj *core; bool external; struct { @@ -54,30 +53,29 @@ struct nouveau_falcon { #define nv_falcon(priv) (&(priv)->base) -#define nouveau_falcon_create(p,e,c,b,d,i,f,r) \ - nouveau_falcon_create_((p), (e), (c), (b), (d), (i), (f), \ +#define nvkm_falcon_create(p,e,c,b,d,i,f,r) \ + nvkm_falcon_create_((p), (e), (c), (b), (d), (i), (f), \ sizeof(**r),(void **)r) -#define nouveau_falcon_destroy(p) \ - nouveau_engine_destroy(&(p)->base) -#define nouveau_falcon_init(p) ({ \ - struct nouveau_falcon *falcon = (p); \ - _nouveau_falcon_init(nv_object(falcon)); \ +#define nvkm_falcon_destroy(p) \ + nvkm_engine_destroy(&(p)->base) +#define nvkm_falcon_init(p) ({ \ + struct nvkm_falcon *falcon = (p); \ + _nvkm_falcon_init(nv_object(falcon)); \ }) -#define nouveau_falcon_fini(p,s) ({ \ - struct nouveau_falcon *falcon = (p); \ - _nouveau_falcon_fini(nv_object(falcon), (s)); \ +#define nvkm_falcon_fini(p,s) ({ \ + struct nvkm_falcon *falcon = (p); \ + _nvkm_falcon_fini(nv_object(falcon), (s)); \ }) -int nouveau_falcon_create_(struct nouveau_object *, struct nouveau_object *, - struct nouveau_oclass *, u32, bool, const char *, +int nvkm_falcon_create_(struct nvkm_object *, struct nvkm_object *, + struct nvkm_oclass *, u32, bool, const char *, const char *, int, void **); -void nouveau_falcon_intr(struct nouveau_subdev *subdev); - -#define _nouveau_falcon_dtor _nouveau_engine_dtor -int _nouveau_falcon_init(struct nouveau_object *); -int _nouveau_falcon_fini(struct nouveau_object *, bool); -u32 _nouveau_falcon_rd32(struct nouveau_object *, u64); -void _nouveau_falcon_wr32(struct nouveau_object *, u64, u32); +void nvkm_falcon_intr(struct nvkm_subdev *subdev); +#define _nvkm_falcon_dtor _nvkm_engine_dtor +int _nvkm_falcon_init(struct nvkm_object *); +int _nvkm_falcon_fini(struct nvkm_object *, bool); +u32 _nvkm_falcon_rd32(struct nvkm_object *, u64); +void _nvkm_falcon_wr32(struct nvkm_object *, u64, u32); #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/engine/xtensa.h b/drivers/gpu/drm/nouveau/include/nvkm/engine/xtensa.h index 306100f..7a216cc 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/engine/xtensa.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/engine/xtensa.h @@ -1,38 +1,35 @@ -#ifndef __NOUVEAU_XTENSA_H__ -#define __NOUVEAU_XTENSA_H__ - +#ifndef __NVKM_XTENSA_H__ +#define __NVKM_XTENSA_H__ #include -#include -#include +struct nvkm_gpuobj; -struct nouveau_xtensa { - struct nouveau_engine base; +struct nvkm_xtensa { + struct nvkm_engine base; u32 addr; - struct nouveau_gpuobj *gpu_fw; + struct nvkm_gpuobj *gpu_fw; u32 fifo_val; u32 unkd28; }; -#define nouveau_xtensa_create(p,e,c,b,d,i,f,r) \ - nouveau_xtensa_create_((p), (e), (c), (b), (d), (i), (f), \ +#define nvkm_xtensa_create(p,e,c,b,d,i,f,r) \ + nvkm_xtensa_create_((p), (e), (c), (b), (d), (i), (f), \ sizeof(**r),(void **)r) -int _nouveau_xtensa_engctx_ctor(struct nouveau_object *, - struct nouveau_object *, - struct nouveau_oclass *, void *, u32, - struct nouveau_object **); +int _nvkm_xtensa_engctx_ctor(struct nvkm_object *, + struct nvkm_object *, + struct nvkm_oclass *, void *, u32, + struct nvkm_object **); -void _nouveau_xtensa_intr(struct nouveau_subdev *); -int nouveau_xtensa_create_(struct nouveau_object *, - struct nouveau_object *, - struct nouveau_oclass *, u32, bool, +void _nvkm_xtensa_intr(struct nvkm_subdev *); +int nvkm_xtensa_create_(struct nvkm_object *, + struct nvkm_object *, + struct nvkm_oclass *, u32, bool, const char *, const char *, int, void **); -#define _nouveau_xtensa_dtor _nouveau_engine_dtor -int _nouveau_xtensa_init(struct nouveau_object *); -int _nouveau_xtensa_fini(struct nouveau_object *, bool); -u32 _nouveau_xtensa_rd32(struct nouveau_object *, u64); -void _nouveau_xtensa_wr32(struct nouveau_object *, u64, u32); - +#define _nvkm_xtensa_dtor _nvkm_engine_dtor +int _nvkm_xtensa_init(struct nvkm_object *); +int _nvkm_xtensa_fini(struct nvkm_object *, bool); +u32 _nvkm_xtensa_rd32(struct nvkm_object *, u64); +void _nvkm_xtensa_wr32(struct nvkm_object *, u64, u32); #endif diff --git a/drivers/gpu/drm/nouveau/include/nvkm/subdev/clk.h b/drivers/gpu/drm/nouveau/include/nvkm/subdev/clk.h index 4524d4e..d42a088 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/subdev/clk.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/subdev/clk.h @@ -2,6 +2,7 @@ #define __NOUVEAU_CLK_H__ #include +#include #include struct nouveau_pll_vals; diff --git a/drivers/gpu/drm/nouveau/nouveau_nvif.c b/drivers/gpu/drm/nouveau/nouveau_nvif.c index 6544b84..7f7bd32 100644 --- a/drivers/gpu/drm/nouveau/nouveau_nvif.c +++ b/drivers/gpu/drm/nouveau/nouveau_nvif.c @@ -70,7 +70,7 @@ nvkm_client_suspend(void *priv) } static void -nvkm_client_fini(void *priv) +nvkm_client_driver_fini(void *priv) { struct nouveau_object *client = priv; nouveau_client_fini(nv_client(client), false); @@ -107,8 +107,8 @@ nvkm_client_ntfy(const void *header, u32 length, const void *data, u32 size) } static int -nvkm_client_init(const char *name, u64 device, const char *cfg, - const char *dbg, void **ppriv) +nvkm_client_driver_init(const char *name, u64 device, const char *cfg, + const char *dbg, void **ppriv) { struct nouveau_client *client; int ret; @@ -125,8 +125,8 @@ nvkm_client_init(const char *name, u64 device, const char *cfg, const struct nvif_driver nvif_driver_nvkm = { .name = "nvkm", - .init = nvkm_client_init, - .fini = nvkm_client_fini, + .init = nvkm_client_driver_init, + .fini = nvkm_client_driver_fini, .suspend = nvkm_client_suspend, .resume = nvkm_client_resume, .ioctl = nvkm_client_ioctl, diff --git a/drivers/gpu/drm/nouveau/nvif/notify.c b/drivers/gpu/drm/nouveau/nvif/notify.c index 0898c31..8e34748 100644 --- a/drivers/gpu/drm/nouveau/nvif/notify.c +++ b/drivers/gpu/drm/nouveau/nvif/notify.c @@ -92,7 +92,7 @@ nvif_notify_func(struct nvif_notify *notify, bool keep) { int ret = notify->func(notify); if (ret == NVIF_NOTIFY_KEEP || - !test_and_clear_bit(NVKM_NOTIFY_USER, ¬ify->flags)) { + !test_and_clear_bit(NVIF_NOTIFY_USER, ¬ify->flags)) { if (!keep) atomic_dec(¬ify->putcnt); else diff --git a/drivers/gpu/drm/nouveau/nvkm/core/client.c b/drivers/gpu/drm/nouveau/nvkm/core/client.c index acff103..878a82f 100644 --- a/drivers/gpu/drm/nouveau/nvkm/core/client.c +++ b/drivers/gpu/drm/nouveau/nvkm/core/client.c @@ -21,21 +21,18 @@ * * Authors: Ben Skeggs */ - -#include #include +#include #include +#include #include -#include -#include -#include +#include #include - -#include +#include struct nvkm_client_notify { - struct nouveau_client *client; + struct nvkm_client *client; struct nvkm_notify n; u8 version; u8 size; @@ -48,12 +45,12 @@ static int nvkm_client_notify(struct nvkm_notify *n) { struct nvkm_client_notify *notify = container_of(n, typeof(*notify), n); - struct nouveau_client *client = notify->client; + struct nvkm_client *client = notify->client; return client->ntfy(¬ify->rep, notify->size, n->data, n->size); } int -nvkm_client_notify_put(struct nouveau_client *client, int index) +nvkm_client_notify_put(struct nvkm_client *client, int index) { if (index < ARRAY_SIZE(client->notify)) { if (client->notify[index]) { @@ -65,7 +62,7 @@ nvkm_client_notify_put(struct nouveau_client *client, int index) } int -nvkm_client_notify_get(struct nouveau_client *client, int index) +nvkm_client_notify_get(struct nvkm_client *client, int index) { if (index < ARRAY_SIZE(client->notify)) { if (client->notify[index]) { @@ -77,7 +74,7 @@ nvkm_client_notify_get(struct nouveau_client *client, int index) } int -nvkm_client_notify_del(struct nouveau_client *client, int index) +nvkm_client_notify_del(struct nvkm_client *client, int index) { if (index < ARRAY_SIZE(client->notify)) { if (client->notify[index]) { @@ -91,10 +88,10 @@ nvkm_client_notify_del(struct nouveau_client *client, int index) } int -nvkm_client_notify_new(struct nouveau_object *object, +nvkm_client_notify_new(struct nvkm_object *object, struct nvkm_event *event, void *data, u32 size) { - struct nouveau_client *client = nouveau_client(object); + struct nvkm_client *client = nvkm_client(object); struct nvkm_client_notify *notify; union { struct nvif_notify_req_v0 v0; @@ -142,7 +139,7 @@ nvkm_client_notify_new(struct nouveau_object *object, } static int -nouveau_client_devlist(struct nouveau_object *object, void *data, u32 size) +nvkm_client_mthd_devlist(struct nvkm_object *object, void *data, u32 size) { union { struct nv_client_devlist_v0 v0; @@ -154,8 +151,7 @@ nouveau_client_devlist(struct nouveau_object *object, void *data, u32 size) nv_ioctl(object, "client devlist vers %d count %d\n", args->v0.version, args->v0.count); if (size == sizeof(args->v0.device[0]) * args->v0.count) { - ret = nouveau_device_list(args->v0.device, - args->v0.count); + ret = nvkm_device_list(args->v0.device, args->v0.count); if (ret >= 0) { args->v0.count = ret; ret = 0; @@ -169,12 +165,11 @@ nouveau_client_devlist(struct nouveau_object *object, void *data, u32 size) } static int -nouveau_client_mthd(struct nouveau_object *object, u32 mthd, - void *data, u32 size) +nvkm_client_mthd(struct nvkm_object *object, u32 mthd, void *data, u32 size) { switch (mthd) { case NV_CLIENT_DEVLIST: - return nouveau_client_devlist(object, data, size); + return nvkm_client_mthd_devlist(object, data, size); default: break; } @@ -182,71 +177,71 @@ nouveau_client_mthd(struct nouveau_object *object, u32 mthd, } static void -nouveau_client_dtor(struct nouveau_object *object) +nvkm_client_dtor(struct nvkm_object *object) { - struct nouveau_client *client = (void *)object; + struct nvkm_client *client = (void *)object; int i; for (i = 0; i < ARRAY_SIZE(client->notify); i++) nvkm_client_notify_del(client, i); - nouveau_object_ref(NULL, &client->device); - nouveau_handle_destroy(client->root); - nouveau_namedb_destroy(&client->namedb); + nvkm_object_ref(NULL, &client->device); + nvkm_handle_destroy(client->root); + nvkm_namedb_destroy(&client->namedb); } -static struct nouveau_oclass -nouveau_client_oclass = { - .ofuncs = &(struct nouveau_ofuncs) { - .dtor = nouveau_client_dtor, - .mthd = nouveau_client_mthd, +static struct nvkm_oclass +nvkm_client_oclass = { + .ofuncs = &(struct nvkm_ofuncs) { + .dtor = nvkm_client_dtor, + .mthd = nvkm_client_mthd, }, }; int -nouveau_client_create_(const char *name, u64 devname, const char *cfg, - const char *dbg, int length, void **pobject) +nvkm_client_create_(const char *name, u64 devname, const char *cfg, + const char *dbg, int length, void **pobject) { - struct nouveau_object *device; - struct nouveau_client *client; + struct nvkm_object *device; + struct nvkm_client *client; int ret; - device = (void *)nouveau_device_find(devname); + device = (void *)nvkm_device_find(devname); if (!device) return -ENODEV; - ret = nouveau_namedb_create_(NULL, NULL, &nouveau_client_oclass, - NV_CLIENT_CLASS, NULL, - (1ULL << NVDEV_ENGINE_DEVICE), - length, pobject); + ret = nvkm_namedb_create_(NULL, NULL, &nvkm_client_oclass, + NV_CLIENT_CLASS, NULL, + (1ULL << NVDEV_ENGINE_DEVICE), + length, pobject); client = *pobject; if (ret) return ret; - ret = nouveau_handle_create(nv_object(client), ~0, ~0, - nv_object(client), &client->root); + ret = nvkm_handle_create(nv_object(client), ~0, ~0, nv_object(client), + &client->root); if (ret) 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); + nvkm_object_ref(device, &client->device); snprintf(client->name, sizeof(client->name), "%s", name); - client->debug = nouveau_dbgopt(dbg, "CLIENT"); + client->debug = nvkm_dbgopt(dbg, "CLIENT"); return 0; } int -nouveau_client_init(struct nouveau_client *client) +nvkm_client_init(struct nvkm_client *client) { int ret; nv_debug(client, "init running\n"); - ret = nouveau_handle_init(client->root); + ret = nvkm_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) +nvkm_client_fini(struct nvkm_client *client, bool suspend) { const char *name[2] = { "fini", "suspend" }; int ret, i; @@ -255,16 +250,16 @@ nouveau_client_fini(struct nouveau_client *client, bool suspend) for (i = 0; i < ARRAY_SIZE(client->notify); i++) nvkm_client_notify_put(client, i); nv_debug(client, "%s object\n", name[suspend]); - ret = nouveau_handle_fini(client->root, suspend); + ret = nvkm_handle_fini(client->root, suspend); nv_debug(client, "%s completed with %d\n", name[suspend], ret); return ret; } const char * -nouveau_client_name(void *obj) +nvkm_client_name(void *obj) { const char *client_name = "unknown"; - struct nouveau_client *client = nouveau_client(obj); + struct nvkm_client *client = nvkm_client(obj); if (client) client_name = client->name; return client_name; diff --git a/drivers/gpu/drm/nouveau/nvkm/core/engctx.c b/drivers/gpu/drm/nouveau/nvkm/core/engctx.c index 892baa4..a9df07a 100644 --- a/drivers/gpu/drm/nouveau/nvkm/core/engctx.c +++ b/drivers/gpu/drm/nouveau/nvkm/core/engctx.c @@ -21,21 +21,15 @@ * * Authors: Ben Skeggs */ - -#include -#include -#include -#include #include - -#include +#include static inline int -nouveau_engctx_exists(struct nouveau_object *parent, - struct nouveau_engine *engine, void **pobject) +nvkm_engctx_exists(struct nvkm_object *parent, + struct nvkm_engine *engine, void **pobject) { - struct nouveau_engctx *engctx; - struct nouveau_object *parctx; + struct nvkm_engctx *engctx; + struct nvkm_object *parctx; list_for_each_entry(engctx, &engine->contexts, head) { parctx = nv_pclass(nv_object(engctx), NV_PARENT_CLASS); @@ -50,16 +44,13 @@ nouveau_engctx_exists(struct nouveau_object *parent, } 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) +nvkm_engctx_create_(struct nvkm_object *parent, struct nvkm_object *engobj, + struct nvkm_oclass *oclass, struct nvkm_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_object *engctx; + struct nvkm_client *client = nvkm_client(parent); + struct nvkm_engine *engine = nv_engine(engobj); + struct nvkm_object *engctx; unsigned long save; int ret; @@ -67,7 +58,7 @@ nouveau_engctx_create_(struct nouveau_object *parent, * and reference it instead of creating a new one */ spin_lock_irqsave(&engine->lock, save); - ret = nouveau_engctx_exists(parent, engine, pobject); + ret = nvkm_engctx_exists(parent, engine, pobject); spin_unlock_irqrestore(&engine->lock, save); if (ret) return ret; @@ -76,13 +67,12 @@ nouveau_engctx_create_(struct nouveau_object *parent, * objects backed by instance memory */ if (size) { - ret = nouveau_gpuobj_create_(parent, engobj, oclass, - NV_ENGCTX_CLASS, - pargpu, size, align, flags, - length, pobject); + ret = nvkm_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); + ret = nvkm_object_create_(parent, engobj, oclass, + NV_ENGCTX_CLASS, length, pobject); } engctx = *pobject; @@ -94,10 +84,10 @@ nouveau_engctx_create_(struct nouveau_object *parent, * it's not possible to allocate the object with it held. */ spin_lock_irqsave(&engine->lock, save); - ret = nouveau_engctx_exists(parent, engine, pobject); + ret = nvkm_engctx_exists(parent, engine, pobject); if (ret) { spin_unlock_irqrestore(&engine->lock, save); - nouveau_object_ref(NULL, &engctx); + nvkm_object_ref(NULL, &engctx); return ret; } @@ -110,13 +100,13 @@ nouveau_engctx_create_(struct nouveau_object *parent, } void -nouveau_engctx_destroy(struct nouveau_engctx *engctx) +nvkm_engctx_destroy(struct nvkm_engctx *engctx) { - struct nouveau_engine *engine = engctx->gpuobj.object.engine; - struct nouveau_client *client = nouveau_client(engctx); + struct nvkm_engine *engine = engctx->gpuobj.object.engine; + struct nvkm_client *client = nvkm_client(engctx); unsigned long save; - nouveau_gpuobj_unmap(&engctx->vma); + nvkm_gpuobj_unmap(&engctx->vma); spin_lock_irqsave(&engine->lock, save); list_del(&engctx->head); spin_unlock_irqrestore(&engine->lock, save); @@ -125,21 +115,21 @@ nouveau_engctx_destroy(struct nouveau_engctx *engctx) atomic_dec(&client->vm->engref[nv_engidx(engine)]); if (engctx->gpuobj.size) - nouveau_gpuobj_destroy(&engctx->gpuobj); + nvkm_gpuobj_destroy(&engctx->gpuobj); else - nouveau_object_destroy(&engctx->gpuobj.object); + nvkm_object_destroy(&engctx->gpuobj.object); } int -nouveau_engctx_init(struct nouveau_engctx *engctx) +nvkm_engctx_init(struct nvkm_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; + struct nvkm_object *object = nv_object(engctx); + struct nvkm_subdev *subdev = nv_subdev(object->engine); + struct nvkm_object *parent; + struct nvkm_subdev *pardev; int ret; - ret = nouveau_gpuobj_init(&engctx->gpuobj); + ret = nvkm_gpuobj_init(&engctx->gpuobj); if (ret) return ret; @@ -162,12 +152,12 @@ nouveau_engctx_init(struct nouveau_engctx *engctx) } int -nouveau_engctx_fini(struct nouveau_engctx *engctx, bool suspend) +nvkm_engctx_fini(struct nvkm_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; + struct nvkm_object *object = nv_object(engctx); + struct nvkm_subdev *subdev = nv_subdev(object->engine); + struct nvkm_object *parent; + struct nvkm_subdev *pardev; int ret = 0; parent = nv_pclass(object->parent, NV_PARENT_CLASS); @@ -185,47 +175,45 @@ nouveau_engctx_fini(struct nouveau_engctx *engctx, bool suspend) } nv_debug(parent, "detached %s context\n", subdev->name); - return nouveau_gpuobj_fini(&engctx->gpuobj, suspend); + return nvkm_gpuobj_fini(&engctx->gpuobj, suspend); } int -_nouveau_engctx_ctor(struct nouveau_object *parent, - struct nouveau_object *engine, - struct nouveau_oclass *oclass, void *data, u32 size, - struct nouveau_object **pobject) +_nvkm_engctx_ctor(struct nvkm_object *parent, struct nvkm_object *engine, + struct nvkm_oclass *oclass, void *data, u32 size, + struct nvkm_object **pobject) { - struct nouveau_engctx *engctx; + struct nvkm_engctx *engctx; int ret; - ret = nouveau_engctx_create(parent, engine, oclass, NULL, 256, 256, - NVOBJ_FLAG_ZERO_ALLOC, &engctx); + ret = nvkm_engctx_create(parent, engine, oclass, NULL, 256, 256, + NVOBJ_FLAG_ZERO_ALLOC, &engctx); *pobject = nv_object(engctx); return ret; } void -_nouveau_engctx_dtor(struct nouveau_object *object) +_nvkm_engctx_dtor(struct nvkm_object *object) { - nouveau_engctx_destroy(nv_engctx(object)); + nvkm_engctx_destroy(nv_engctx(object)); } int -_nouveau_engctx_init(struct nouveau_object *object) +_nvkm_engctx_init(struct nvkm_object *object) { - return nouveau_engctx_init(nv_engctx(object)); + return nvkm_engctx_init(nv_engctx(object)); } - int -_nouveau_engctx_fini(struct nouveau_object *object, bool suspend) +_nvkm_engctx_fini(struct nvkm_object *object, bool suspend) { - return nouveau_engctx_fini(nv_engctx(object), suspend); + return nvkm_engctx_fini(nv_engctx(object), suspend); } -struct nouveau_object * -nouveau_engctx_get(struct nouveau_engine *engine, u64 addr) +struct nvkm_object * +nvkm_engctx_get(struct nvkm_engine *engine, u64 addr) { - struct nouveau_engctx *engctx; + struct nvkm_engctx *engctx; unsigned long flags; spin_lock_irqsave(&engine->lock, flags); @@ -240,11 +228,11 @@ nouveau_engctx_get(struct nouveau_engine *engine, u64 addr) } void -nouveau_engctx_put(struct nouveau_object *object) +nvkm_engctx_put(struct nvkm_object *object) { if (object) { - struct nouveau_engine *engine = nv_engine(object->engine); - struct nouveau_engctx *engctx = nv_engctx(object); + struct nvkm_engine *engine = nv_engine(object->engine); + struct nvkm_engctx *engctx = nv_engctx(object); spin_unlock_irqrestore(&engine->lock, engctx->save); } } diff --git a/drivers/gpu/drm/nouveau/nvkm/core/engine.c b/drivers/gpu/drm/nouveau/nvkm/core/engine.c index c9414b1..6082017 100644 --- a/drivers/gpu/drm/nouveau/nvkm/core/engine.c +++ b/drivers/gpu/drm/nouveau/nvkm/core/engine.c @@ -21,42 +21,40 @@ * * Authors: Ben Skeggs */ - -#include #include +#include #include -struct nouveau_engine * -nouveau_engine(void *obj, int idx) +struct nvkm_engine * +nvkm_engine(void *obj, int idx) { - obj = nouveau_subdev(obj, idx); + obj = nvkm_subdev(obj, idx); if (obj && nv_iclass(obj, NV_ENGINE_CLASS)) return nv_engine(obj); return NULL; } 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) +nvkm_engine_create_(struct nvkm_object *parent, struct nvkm_object *engobj, + struct nvkm_oclass *oclass, bool enable, + const char *iname, const char *fname, + int length, void **pobject) { - struct nouveau_engine *engine; + struct nvkm_engine *engine; int ret; - ret = nouveau_subdev_create_(parent, engobj, oclass, NV_ENGINE_CLASS, - iname, fname, length, pobject); + ret = nvkm_subdev_create_(parent, engobj, oclass, NV_ENGINE_CLASS, + iname, fname, length, pobject); engine = *pobject; if (ret) return ret; if (parent) { - struct nouveau_device *device = nv_device(parent); + struct nvkm_device *device = nv_device(parent); int engidx = nv_engidx(engine); if (device->disable_mask & (1ULL << engidx)) { - if (!nouveau_boolopt(device->cfgopt, iname, false)) { + if (!nvkm_boolopt(device->cfgopt, iname, false)) { nv_debug(engine, "engine disabled by hw/fw\n"); return -ENODEV; } @@ -64,7 +62,7 @@ nouveau_engine_create_(struct nouveau_object *parent, nv_warn(engine, "ignoring hw/fw engine disable\n"); } - if (!nouveau_boolopt(device->cfgopt, iname, enable)) { + if (!nvkm_boolopt(device->cfgopt, iname, enable)) { if (!enable) nv_warn(engine, "disabled, %s=1 to enable\n", iname); return -ENODEV; diff --git a/drivers/gpu/drm/nouveau/nvkm/core/enum.c b/drivers/gpu/drm/nouveau/nvkm/core/enum.c index dd43479..4f92bfc 100644 --- a/drivers/gpu/drm/nouveau/nvkm/core/enum.c +++ b/drivers/gpu/drm/nouveau/nvkm/core/enum.c @@ -24,12 +24,10 @@ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * */ - -#include #include -const struct nouveau_enum * -nouveau_enum_find(const struct nouveau_enum *en, u32 value) +const struct nvkm_enum * +nvkm_enum_find(const struct nvkm_enum *en, u32 value) { while (en->name) { if (en->value == value) @@ -40,10 +38,10 @@ nouveau_enum_find(const struct nouveau_enum *en, u32 value) return NULL; } -const struct nouveau_enum * -nouveau_enum_print(const struct nouveau_enum *en, u32 value) +const struct nvkm_enum * +nvkm_enum_print(const struct nvkm_enum *en, u32 value) { - en = nouveau_enum_find(en, value); + en = nvkm_enum_find(en, value); if (en) pr_cont("%s", en->name); else @@ -52,7 +50,7 @@ nouveau_enum_print(const struct nouveau_enum *en, u32 value) } void -nouveau_bitfield_print(const struct nouveau_bitfield *bf, u32 value) +nvkm_bitfield_print(const struct nvkm_bitfield *bf, u32 value) { while (bf->name) { if (value & bf->mask) { diff --git a/drivers/gpu/drm/nouveau/nvkm/core/event.c b/drivers/gpu/drm/nouveau/nvkm/core/event.c index 760947e..4e8d3fa 100644 --- a/drivers/gpu/drm/nouveau/nvkm/core/event.c +++ b/drivers/gpu/drm/nouveau/nvkm/core/event.c @@ -19,9 +19,8 @@ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ - -#include #include +#include void nvkm_event_put(struct nvkm_event *event, u32 types, int index) diff --git a/drivers/gpu/drm/nouveau/nvkm/core/gpuobj.c b/drivers/gpu/drm/nouveau/nvkm/core/gpuobj.c index 68a4232..0c5cb55 100644 --- a/drivers/gpu/drm/nouveau/nvkm/core/gpuobj.c +++ b/drivers/gpu/drm/nouveau/nvkm/core/gpuobj.c @@ -21,8 +21,6 @@ * * Authors: Ben Skeggs */ - -#include #include #include @@ -30,7 +28,7 @@ #include void -nouveau_gpuobj_destroy(struct nouveau_gpuobj *gpuobj) +nvkm_gpuobj_destroy(struct nvkm_gpuobj *gpuobj) { int i; @@ -39,29 +37,25 @@ nouveau_gpuobj_destroy(struct nouveau_gpuobj *gpuobj) nv_wo32(gpuobj, i, 0x00000000); } - if (gpuobj->node) { - nouveau_mm_free(&nv_gpuobj(gpuobj->parent)->heap, - &gpuobj->node); - } + if (gpuobj->node) + nvkm_mm_free(&nv_gpuobj(gpuobj->parent)->heap, &gpuobj->node); if (gpuobj->heap.block_size) - nouveau_mm_fini(&gpuobj->heap); + nvkm_mm_fini(&gpuobj->heap); - nouveau_object_destroy(&gpuobj->object); + nvkm_object_destroy(&gpuobj->object); } int -nouveau_gpuobj_create_(struct nouveau_object *parent, - struct nouveau_object *engine, - struct nouveau_oclass *oclass, u32 pclass, - struct nouveau_object *pargpu, - u32 size, u32 align, u32 flags, - int length, void **pobject) +nvkm_gpuobj_create_(struct nvkm_object *parent, struct nvkm_object *engine, + struct nvkm_oclass *oclass, u32 pclass, + struct nvkm_object *pargpu, u32 size, u32 align, u32 flags, + int length, void **pobject) { - struct nouveau_instmem *imem = nouveau_instmem(parent); - struct nouveau_bar *bar = nouveau_bar(parent); - struct nouveau_gpuobj *gpuobj; - struct nouveau_mm *heap = NULL; + struct nvkm_instmem *imem = nvkm_instmem(parent); + struct nvkm_bar *bar = nvkm_bar(parent); + struct nvkm_gpuobj *gpuobj; + struct nvkm_mm *heap = NULL; int ret, i; u64 addr; @@ -92,19 +86,19 @@ nouveau_gpuobj_create_(struct nouveau_object *parent, size = nv_memobj(pargpu)->size; if (bar && bar->alloc) { - struct nouveau_instobj *iobj = (void *)parent; - struct nouveau_mem **mem = (void *)(iobj + 1); - struct nouveau_mem *node = *mem; + struct nvkm_instobj *iobj = (void *)parent; + struct nvkm_mem **mem = (void *)(iobj + 1); + struct nvkm_mem *node = *mem; if (!bar->alloc(bar, parent, node, &pargpu)) { - nouveau_object_ref(NULL, &parent); + nvkm_object_ref(NULL, &parent); parent = pargpu; } } } - ret = nouveau_object_create_(parent, engine, oclass, pclass | - NV_GPUOBJ_CLASS, length, pobject); - nouveau_object_ref(NULL, &parent); + ret = nvkm_object_create_(parent, engine, oclass, pclass | + NV_GPUOBJ_CLASS, length, pobject); + nvkm_object_ref(NULL, &parent); gpuobj = *pobject; if (ret) return ret; @@ -115,8 +109,8 @@ nouveau_gpuobj_create_(struct nouveau_object *parent, gpuobj->size = size; if (heap) { - ret = nouveau_mm_head(heap, 0, 1, size, size, - max(align, (u32)1), &gpuobj->node); + ret = nvkm_mm_head(heap, 0, 1, size, size, max(align, (u32)1), + &gpuobj->node); if (ret) return ret; @@ -124,7 +118,7 @@ nouveau_gpuobj_create_(struct nouveau_object *parent, } if (gpuobj->flags & NVOBJ_FLAG_HEAP) { - ret = nouveau_mm_init(&gpuobj->heap, 0, gpuobj->size, 1); + ret = nvkm_mm_init(&gpuobj->heap, 0, gpuobj->size, 1); if (ret) return ret; } @@ -137,26 +131,25 @@ nouveau_gpuobj_create_(struct nouveau_object *parent, return ret; } -struct nouveau_gpuobj_class { - struct nouveau_object *pargpu; +struct nvkm_gpuobj_class { + struct nvkm_object *pargpu; u64 size; u32 align; u32 flags; }; static int -_nouveau_gpuobj_ctor(struct nouveau_object *parent, - struct nouveau_object *engine, - struct nouveau_oclass *oclass, void *data, u32 size, - struct nouveau_object **pobject) +_nvkm_gpuobj_ctor(struct nvkm_object *parent, struct nvkm_object *engine, + struct nvkm_oclass *oclass, void *data, u32 size, + struct nvkm_object **pobject) { - struct nouveau_gpuobj_class *args = data; - struct nouveau_gpuobj *object; + struct nvkm_gpuobj_class *args = data; + struct nvkm_gpuobj *object; int ret; - ret = nouveau_gpuobj_create(parent, engine, oclass, 0, args->pargpu, - args->size, args->align, args->flags, - &object); + ret = nvkm_gpuobj_create(parent, engine, oclass, 0, args->pargpu, + args->size, args->align, args->flags, + &object); *pobject = nv_object(object); if (ret) return ret; @@ -165,63 +158,63 @@ _nouveau_gpuobj_ctor(struct nouveau_object *parent, } void -_nouveau_gpuobj_dtor(struct nouveau_object *object) +_nvkm_gpuobj_dtor(struct nvkm_object *object) { - nouveau_gpuobj_destroy(nv_gpuobj(object)); + nvkm_gpuobj_destroy(nv_gpuobj(object)); } int -_nouveau_gpuobj_init(struct nouveau_object *object) +_nvkm_gpuobj_init(struct nvkm_object *object) { - return nouveau_gpuobj_init(nv_gpuobj(object)); + return nvkm_gpuobj_init(nv_gpuobj(object)); } int -_nouveau_gpuobj_fini(struct nouveau_object *object, bool suspend) +_nvkm_gpuobj_fini(struct nvkm_object *object, bool suspend) { - return nouveau_gpuobj_fini(nv_gpuobj(object), suspend); + return nvkm_gpuobj_fini(nv_gpuobj(object), suspend); } u32 -_nouveau_gpuobj_rd32(struct nouveau_object *object, u64 addr) +_nvkm_gpuobj_rd32(struct nvkm_object *object, u64 addr) { - struct nouveau_gpuobj *gpuobj = nv_gpuobj(object); - struct nouveau_ofuncs *pfuncs = nv_ofuncs(gpuobj->parent); + struct nvkm_gpuobj *gpuobj = nv_gpuobj(object); + struct nvkm_ofuncs *pfuncs = nv_ofuncs(gpuobj->parent); if (gpuobj->node) addr += gpuobj->node->offset; return pfuncs->rd32(gpuobj->parent, addr); } void -_nouveau_gpuobj_wr32(struct nouveau_object *object, u64 addr, u32 data) +_nvkm_gpuobj_wr32(struct nvkm_object *object, u64 addr, u32 data) { - struct nouveau_gpuobj *gpuobj = nv_gpuobj(object); - struct nouveau_ofuncs *pfuncs = nv_ofuncs(gpuobj->parent); + struct nvkm_gpuobj *gpuobj = nv_gpuobj(object); + struct nvkm_ofuncs *pfuncs = nv_ofuncs(gpuobj->parent); if (gpuobj->node) addr += gpuobj->node->offset; pfuncs->wr32(gpuobj->parent, addr, data); } -static struct nouveau_oclass -_nouveau_gpuobj_oclass = { +static struct nvkm_oclass +_nvkm_gpuobj_oclass = { .handle = 0x00000000, - .ofuncs = &(struct nouveau_ofuncs) { - .ctor = _nouveau_gpuobj_ctor, - .dtor = _nouveau_gpuobj_dtor, - .init = _nouveau_gpuobj_init, - .fini = _nouveau_gpuobj_fini, - .rd32 = _nouveau_gpuobj_rd32, - .wr32 = _nouveau_gpuobj_wr32, + .ofuncs = &(struct nvkm_ofuncs) { + .ctor = _nvkm_gpuobj_ctor, + .dtor = _nvkm_gpuobj_dtor, + .init = _nvkm_gpuobj_init, + .fini = _nvkm_gpuobj_fini, + .rd32 = _nvkm_gpuobj_rd32, + .wr32 = _nvkm_gpuobj_wr32, }, }; int -nouveau_gpuobj_new(struct nouveau_object *parent, struct nouveau_object *pargpu, - u32 size, u32 align, u32 flags, - struct nouveau_gpuobj **pgpuobj) +nvkm_gpuobj_new(struct nvkm_object *parent, struct nvkm_object *pargpu, + u32 size, u32 align, u32 flags, + struct nvkm_gpuobj **pgpuobj) { - struct nouveau_object *engine = parent; - struct nouveau_gpuobj_class args = { + struct nvkm_object *engine = parent; + struct nvkm_gpuobj_class args = { .pargpu = pargpu, .size = size, .align = align, @@ -232,22 +225,21 @@ nouveau_gpuobj_new(struct nouveau_object *parent, struct nouveau_object *pargpu, engine = &engine->engine->subdev.object; BUG_ON(engine == NULL); - return nouveau_object_ctor(parent, engine, &_nouveau_gpuobj_oclass, - &args, sizeof(args), - (struct nouveau_object **)pgpuobj); + return nvkm_object_ctor(parent, engine, &_nvkm_gpuobj_oclass, + &args, sizeof(args), + (struct nvkm_object **)pgpuobj); } int -nouveau_gpuobj_map(struct nouveau_gpuobj *gpuobj, u32 access, - struct nouveau_vma *vma) +nvkm_gpuobj_map(struct nvkm_gpuobj *gpuobj, u32 access, struct nvkm_vma *vma) { - struct nouveau_bar *bar = nouveau_bar(gpuobj); + struct nvkm_bar *bar = nvkm_bar(gpuobj); int ret = -EINVAL; if (bar && bar->umap) { - struct nouveau_instobj *iobj = (void *) + struct nvkm_instobj *iobj = (void *) nv_pclass(nv_object(gpuobj), NV_MEMOBJ_CLASS); - struct nouveau_mem **mem = (void *)(iobj + 1); + struct nvkm_mem **mem = (void *)(iobj + 1); ret = bar->umap(bar, *mem, access, vma); } @@ -255,28 +247,28 @@ nouveau_gpuobj_map(struct nouveau_gpuobj *gpuobj, u32 access, } int -nouveau_gpuobj_map_vm(struct nouveau_gpuobj *gpuobj, struct nouveau_vm *vm, - u32 access, struct nouveau_vma *vma) +nvkm_gpuobj_map_vm(struct nvkm_gpuobj *gpuobj, struct nvkm_vm *vm, + u32 access, struct nvkm_vma *vma) { - struct nouveau_instobj *iobj = (void *) + struct nvkm_instobj *iobj = (void *) nv_pclass(nv_object(gpuobj), NV_MEMOBJ_CLASS); - struct nouveau_mem **mem = (void *)(iobj + 1); + struct nvkm_mem **mem = (void *)(iobj + 1); int ret; - ret = nouveau_vm_get(vm, gpuobj->size, 12, access, vma); + ret = nvkm_vm_get(vm, gpuobj->size, 12, access, vma); if (ret) return ret; - nouveau_vm_map(vma, *mem); + nvkm_vm_map(vma, *mem); return 0; } void -nouveau_gpuobj_unmap(struct nouveau_vma *vma) +nvkm_gpuobj_unmap(struct nvkm_vma *vma) { if (vma->node) { - nouveau_vm_unmap(vma); - nouveau_vm_put(vma); + nvkm_vm_unmap(vma); + nvkm_vm_put(vma); } } @@ -286,37 +278,37 @@ nouveau_gpuobj_unmap(struct nouveau_vma *vma) */ static void -nouveau_gpudup_dtor(struct nouveau_object *object) +nvkm_gpudup_dtor(struct nvkm_object *object) { - struct nouveau_gpuobj *gpuobj = (void *)object; - nouveau_object_ref(NULL, &gpuobj->parent); - nouveau_object_destroy(&gpuobj->object); + struct nvkm_gpuobj *gpuobj = (void *)object; + nvkm_object_ref(NULL, &gpuobj->parent); + nvkm_object_destroy(&gpuobj->object); } -static struct nouveau_oclass -nouveau_gpudup_oclass = { +static struct nvkm_oclass +nvkm_gpudup_oclass = { .handle = NV_GPUOBJ_CLASS, - .ofuncs = &(struct nouveau_ofuncs) { - .dtor = nouveau_gpudup_dtor, - .init = nouveau_object_init, - .fini = nouveau_object_fini, + .ofuncs = &(struct nvkm_ofuncs) { + .dtor = nvkm_gpudup_dtor, + .init = nvkm_object_init, + .fini = nvkm_object_fini, }, }; int -nouveau_gpuobj_dup(struct nouveau_object *parent, struct nouveau_gpuobj *base, - struct nouveau_gpuobj **pgpuobj) +nvkm_gpuobj_dup(struct nvkm_object *parent, struct nvkm_gpuobj *base, + struct nvkm_gpuobj **pgpuobj) { - struct nouveau_gpuobj *gpuobj; + struct nvkm_gpuobj *gpuobj; int ret; - ret = nouveau_object_create(parent, &parent->engine->subdev.object, - &nouveau_gpudup_oclass, 0, &gpuobj); + ret = nvkm_object_create(parent, &parent->engine->subdev.object, + &nvkm_gpudup_oclass, 0, &gpuobj); *pgpuobj = gpuobj; if (ret) return ret; - nouveau_object_ref(nv_object(base), &gpuobj->parent); + nvkm_object_ref(nv_object(base), &gpuobj->parent); gpuobj->addr = base->addr; gpuobj->size = base->size; return 0; diff --git a/drivers/gpu/drm/nouveau/nvkm/core/handle.c b/drivers/gpu/drm/nouveau/nvkm/core/handle.c index 13f816c..dc7ff10 100644 --- a/drivers/gpu/drm/nouveau/nvkm/core/handle.c +++ b/drivers/gpu/drm/nouveau/nvkm/core/handle.c @@ -21,31 +21,29 @@ * * Authors: Ben Skeggs */ - -#include #include #include #define hprintk(h,l,f,a...) do { \ - struct nouveau_client *c = nouveau_client((h)->object); \ - struct nouveau_handle *p = (h)->parent; u32 n = p ? p->name : ~0; \ + struct nvkm_client *c = nvkm_client((h)->object); \ + struct nvkm_handle *p = (h)->parent; u32 n = p ? p->name : ~0; \ nv_printk((c), l, "0x%08x:0x%08x "f, n, (h)->name, ##a); \ } while(0) int -nouveau_handle_init(struct nouveau_handle *handle) +nvkm_handle_init(struct nvkm_handle *handle) { - struct nouveau_handle *item; + struct nvkm_handle *item; int ret; hprintk(handle, TRACE, "init running\n"); - ret = nouveau_object_inc(handle->object); + ret = nvkm_object_inc(handle->object); if (ret) return ret; hprintk(handle, TRACE, "init children\n"); list_for_each_entry(item, &handle->tree, head) { - ret = nouveau_handle_init(item); + ret = nvkm_handle_init(item); if (ret) goto fail; } @@ -55,30 +53,30 @@ nouveau_handle_init(struct nouveau_handle *handle) fail: hprintk(handle, ERROR, "init failed with %d\n", ret); list_for_each_entry_continue_reverse(item, &handle->tree, head) { - nouveau_handle_fini(item, false); + nvkm_handle_fini(item, false); } - nouveau_object_dec(handle->object, false); + nvkm_object_dec(handle->object, false); return ret; } int -nouveau_handle_fini(struct nouveau_handle *handle, bool suspend) +nvkm_handle_fini(struct nvkm_handle *handle, bool suspend) { static char *name[2] = { "fini", "suspend" }; - struct nouveau_handle *item; + struct nvkm_handle *item; int ret; hprintk(handle, TRACE, "%s children\n", name[suspend]); list_for_each_entry(item, &handle->tree, head) { - ret = nouveau_handle_fini(item, suspend); + ret = nvkm_handle_fini(item, suspend); if (ret && suspend) goto fail; } hprintk(handle, TRACE, "%s running\n", name[suspend]); if (handle->object) { - ret = nouveau_object_dec(handle->object, suspend); + ret = nvkm_object_dec(handle->object, suspend); if (ret && suspend) goto fail; } @@ -88,7 +86,7 @@ nouveau_handle_fini(struct nouveau_handle *handle, bool suspend) fail: hprintk(handle, ERROR, "%s failed with %d\n", name[suspend], ret); list_for_each_entry_continue_reverse(item, &handle->tree, head) { - int rret = nouveau_handle_init(item); + int rret = nvkm_handle_init(item); if (rret) hprintk(handle, FATAL, "failed to restart, %d\n", rret); } @@ -97,12 +95,11 @@ fail: } int -nouveau_handle_create(struct nouveau_object *parent, u32 _parent, u32 _handle, - struct nouveau_object *object, - struct nouveau_handle **phandle) +nvkm_handle_create(struct nvkm_object *parent, u32 _parent, u32 _handle, + struct nvkm_object *object, struct nvkm_handle **phandle) { - struct nouveau_object *namedb; - struct nouveau_handle *handle; + struct nvkm_object *namedb; + struct nvkm_handle *handle; int ret; namedb = parent; @@ -118,7 +115,7 @@ nouveau_handle_create(struct nouveau_object *parent, u32 _parent, u32 _handle, handle->name = _handle; handle->priv = ~0; - ret = nouveau_namedb_insert(nv_namedb(namedb), _handle, object, handle); + ret = nvkm_namedb_insert(nv_namedb(namedb), _handle, object, handle); if (ret) { kfree(handle); return ret; @@ -127,7 +124,7 @@ nouveau_handle_create(struct nouveau_object *parent, u32 _parent, u32 _handle, if (nv_parent(parent)->object_attach) { ret = nv_parent(parent)->object_attach(parent, object, _handle); if (ret < 0) { - nouveau_handle_destroy(handle); + nvkm_handle_destroy(handle); return ret; } @@ -138,10 +135,10 @@ nouveau_handle_create(struct nouveau_object *parent, u32 _parent, u32 _handle, while (!nv_iclass(namedb, NV_CLIENT_CLASS)) namedb = namedb->parent; - handle->parent = nouveau_namedb_get(nv_namedb(namedb), _parent); + handle->parent = nvkm_namedb_get(nv_namedb(namedb), _parent); if (handle->parent) { list_add(&handle->head, &handle->parent->tree); - nouveau_namedb_put(handle->parent); + nvkm_namedb_put(handle->parent); } } @@ -151,74 +148,74 @@ nouveau_handle_create(struct nouveau_object *parent, u32 _parent, u32 _handle, } void -nouveau_handle_destroy(struct nouveau_handle *handle) +nvkm_handle_destroy(struct nvkm_handle *handle) { - struct nouveau_handle *item, *temp; + struct nvkm_handle *item, *temp; hprintk(handle, TRACE, "destroy running\n"); list_for_each_entry_safe(item, temp, &handle->tree, head) { - nouveau_handle_destroy(item); + nvkm_handle_destroy(item); } list_del(&handle->head); if (handle->priv != ~0) { - struct nouveau_object *parent = handle->parent->object; + struct nvkm_object *parent = handle->parent->object; nv_parent(parent)->object_detach(parent, handle->priv); } hprintk(handle, TRACE, "destroy completed\n"); - nouveau_namedb_remove(handle); + nvkm_namedb_remove(handle); kfree(handle); } -struct nouveau_object * -nouveau_handle_ref(struct nouveau_object *parent, u32 name) +struct nvkm_object * +nvkm_handle_ref(struct nvkm_object *parent, u32 name) { - struct nouveau_object *object = NULL; - struct nouveau_handle *handle; + struct nvkm_object *object = NULL; + struct nvkm_handle *handle; while (!nv_iclass(parent, NV_NAMEDB_CLASS)) parent = parent->parent; - handle = nouveau_namedb_get(nv_namedb(parent), name); + handle = nvkm_namedb_get(nv_namedb(parent), name); if (handle) { - nouveau_object_ref(handle->object, &object); - nouveau_namedb_put(handle); + nvkm_object_ref(handle->object, &object); + nvkm_namedb_put(handle); } return object; } -struct nouveau_handle * -nouveau_handle_get_class(struct nouveau_object *engctx, u16 oclass) +struct nvkm_handle * +nvkm_handle_get_class(struct nvkm_object *engctx, u16 oclass) { - struct nouveau_namedb *namedb; + struct nvkm_namedb *namedb; if (engctx && (namedb = (void *)nv_pclass(engctx, NV_NAMEDB_CLASS))) - return nouveau_namedb_get_class(namedb, oclass); + return nvkm_namedb_get_class(namedb, oclass); return NULL; } -struct nouveau_handle * -nouveau_handle_get_vinst(struct nouveau_object *engctx, u64 vinst) +struct nvkm_handle * +nvkm_handle_get_vinst(struct nvkm_object *engctx, u64 vinst) { - struct nouveau_namedb *namedb; + struct nvkm_namedb *namedb; if (engctx && (namedb = (void *)nv_pclass(engctx, NV_NAMEDB_CLASS))) - return nouveau_namedb_get_vinst(namedb, vinst); + return nvkm_namedb_get_vinst(namedb, vinst); return NULL; } -struct nouveau_handle * -nouveau_handle_get_cinst(struct nouveau_object *engctx, u32 cinst) +struct nvkm_handle * +nvkm_handle_get_cinst(struct nvkm_object *engctx, u32 cinst) { - struct nouveau_namedb *namedb; + struct nvkm_namedb *namedb; if (engctx && (namedb = (void *)nv_pclass(engctx, NV_NAMEDB_CLASS))) - return nouveau_namedb_get_cinst(namedb, cinst); + return nvkm_namedb_get_cinst(namedb, cinst); return NULL; } void -nouveau_handle_put(struct nouveau_handle *handle) +nvkm_handle_put(struct nvkm_handle *handle) { if (handle) - nouveau_namedb_put(handle); + nvkm_namedb_put(handle); } diff --git a/drivers/gpu/drm/nouveau/nvkm/core/ioctl.c b/drivers/gpu/drm/nouveau/nvkm/core/ioctl.c index bdfabb4..4459ff5 100644 --- a/drivers/gpu/drm/nouveau/nvkm/core/ioctl.c +++ b/drivers/gpu/drm/nouveau/nvkm/core/ioctl.c @@ -21,23 +21,19 @@ * * Authors: Ben Skeggs */ - -#include -#include +#include +#include +#include #include #include -#include -#include -#include -#include #include #include static int -nvkm_ioctl_nop(struct nouveau_handle *handle, void *data, u32 size) +nvkm_ioctl_nop(struct nvkm_handle *handle, void *data, u32 size) { - struct nouveau_object *object = handle->object; + struct nvkm_object *object = handle->object; union { struct nvif_ioctl_nop none; } *args = data; @@ -52,9 +48,9 @@ nvkm_ioctl_nop(struct nouveau_handle *handle, void *data, u32 size) } static int -nvkm_ioctl_sclass(struct nouveau_handle *handle, void *data, u32 size) +nvkm_ioctl_sclass(struct nvkm_handle *handle, void *data, u32 size) { - struct nouveau_object *object = handle->object; + struct nvkm_object *object = handle->object; union { struct nvif_ioctl_sclass_v0 v0; } *args = data; @@ -70,8 +66,8 @@ nvkm_ioctl_sclass(struct nouveau_handle *handle, void *data, u32 size) nv_ioctl(object, "sclass vers %d count %d\n", args->v0.version, args->v0.count); if (size == args->v0.count * sizeof(args->v0.oclass[0])) { - ret = nouveau_parent_lclass(object, args->v0.oclass, - args->v0.count); + ret = nvkm_parent_lclass(object, args->v0.oclass, + args->v0.count); if (ret >= 0) { args->v0.count = ret; ret = 0; @@ -85,17 +81,17 @@ nvkm_ioctl_sclass(struct nouveau_handle *handle, void *data, u32 size) } static int -nvkm_ioctl_new(struct nouveau_handle *handle, void *data, u32 size) +nvkm_ioctl_new(struct nvkm_handle *handle, void *data, u32 size) { union { struct nvif_ioctl_new_v0 v0; } *args = data; - struct nouveau_client *client = nouveau_client(handle->object); - struct nouveau_object *engctx = NULL; - struct nouveau_object *object = NULL; - struct nouveau_parent *parent; - struct nouveau_object *engine; - struct nouveau_oclass *oclass; + struct nvkm_client *client = nvkm_client(handle->object); + struct nvkm_object *engctx = NULL; + struct nvkm_object *object = NULL; + struct nvkm_parent *parent; + struct nvkm_object *engine; + struct nvkm_oclass *oclass; u32 _handle, _oclass; int ret; @@ -108,8 +104,8 @@ nvkm_ioctl_new(struct nouveau_handle *handle, void *data, u32 size) nv_ioctl(client, "new vers %d handle %08x class %08x " "route %02x token %llx\n", - args->v0.version, _handle, _oclass, - args->v0.route, args->v0.token); + args->v0.version, _handle, _oclass, + args->v0.route, args->v0.token); if (!nv_iclass(handle->object, NV_PARENT_CLASS)) { nv_debug(handle->object, "cannot have children (ctor)\n"); @@ -120,7 +116,7 @@ nvkm_ioctl_new(struct nouveau_handle *handle, void *data, u32 size) parent = nv_parent(handle->object); /* check that parent supports the requested subclass */ - ret = nouveau_parent_sclass(&parent->object, _oclass, &engine, &oclass); + ret = nvkm_parent_sclass(&parent->object, _oclass, &engine, &oclass); if (ret) { nv_debug(parent, "illegal class 0x%04x\n", _oclass); goto fail_class; @@ -131,7 +127,7 @@ nvkm_ioctl_new(struct nouveau_handle *handle, void *data, u32 size) * state calculated at init (ie. default context construction) */ if (engine) { - ret = nouveau_object_inc(engine); + ret = nvkm_object_inc(engine); if (ret) goto fail_class; } @@ -140,53 +136,53 @@ nvkm_ioctl_new(struct nouveau_handle *handle, void *data, u32 size) * between the parent and its children (eg. PGRAPH context) */ if (engine && nv_engine(engine)->cclass) { - ret = nouveau_object_ctor(&parent->object, engine, - nv_engine(engine)->cclass, - data, size, &engctx); + ret = nvkm_object_ctor(&parent->object, engine, + nv_engine(engine)->cclass, + data, size, &engctx); if (ret) goto fail_engctx; } else { - nouveau_object_ref(&parent->object, &engctx); + nvkm_object_ref(&parent->object, &engctx); } /* finally, create new object and bind it to its handle */ - ret = nouveau_object_ctor(engctx, engine, oclass, data, size, &object); + ret = nvkm_object_ctor(engctx, engine, oclass, data, size, &object); client->data = object; if (ret) goto fail_ctor; - ret = nouveau_object_inc(object); + ret = nvkm_object_inc(object); if (ret) goto fail_init; - ret = nouveau_handle_create(&parent->object, handle->name, - _handle, object, &handle); + ret = nvkm_handle_create(&parent->object, handle->name, + _handle, object, &handle); if (ret) goto fail_handle; - ret = nouveau_handle_init(handle); + ret = nvkm_handle_init(handle); handle->route = args->v0.route; handle->token = args->v0.token; if (ret) - nouveau_handle_destroy(handle); + nvkm_handle_destroy(handle); fail_handle: - nouveau_object_dec(object, false); + nvkm_object_dec(object, false); fail_init: - nouveau_object_ref(NULL, &object); + nvkm_object_ref(NULL, &object); fail_ctor: - nouveau_object_ref(NULL, &engctx); + nvkm_object_ref(NULL, &engctx); fail_engctx: if (engine) - nouveau_object_dec(engine, false); + nvkm_object_dec(engine, false); fail_class: return ret; } static int -nvkm_ioctl_del(struct nouveau_handle *handle, void *data, u32 size) +nvkm_ioctl_del(struct nvkm_handle *handle, void *data, u32 size) { - struct nouveau_object *object = handle->object; + struct nvkm_object *object = handle->object; union { struct nvif_ioctl_del none; } *args = data; @@ -195,18 +191,18 @@ nvkm_ioctl_del(struct nouveau_handle *handle, void *data, u32 size) nv_ioctl(object, "delete size %d\n", size); if (nvif_unvers(args->none)) { nv_ioctl(object, "delete\n"); - nouveau_handle_fini(handle, false); - nouveau_handle_destroy(handle); + nvkm_handle_fini(handle, false); + nvkm_handle_destroy(handle); } return ret; } static int -nvkm_ioctl_mthd(struct nouveau_handle *handle, void *data, u32 size) +nvkm_ioctl_mthd(struct nvkm_handle *handle, void *data, u32 size) { - struct nouveau_object *object = handle->object; - struct nouveau_ofuncs *ofuncs = object->oclass->ofuncs; + struct nvkm_object *object = handle->object; + struct nvkm_ofuncs *ofuncs = object->oclass->ofuncs; union { struct nvif_ioctl_mthd_v0 v0; } *args = data; @@ -225,10 +221,10 @@ nvkm_ioctl_mthd(struct nouveau_handle *handle, void *data, u32 size) static int -nvkm_ioctl_rd(struct nouveau_handle *handle, void *data, u32 size) +nvkm_ioctl_rd(struct nvkm_handle *handle, void *data, u32 size) { - struct nouveau_object *object = handle->object; - struct nouveau_ofuncs *ofuncs = object->oclass->ofuncs; + struct nvkm_object *object = handle->object; + struct nvkm_ofuncs *ofuncs = object->oclass->ofuncs; union { struct nvif_ioctl_rd_v0 v0; } *args = data; @@ -237,7 +233,7 @@ nvkm_ioctl_rd(struct nouveau_handle *handle, void *data, u32 size) nv_ioctl(object, "rd size %d\n", size); if (nvif_unpack(args->v0, 0, 0, false)) { nv_ioctl(object, "rd vers %d size %d addr %016llx\n", - args->v0.version, args->v0.size, args->v0.addr); + args->v0.version, args->v0.size, args->v0.addr); switch (args->v0.size) { case 1: if (ret = -ENODEV, ofuncs->rd08) { @@ -267,10 +263,10 @@ nvkm_ioctl_rd(struct nouveau_handle *handle, void *data, u32 size) } static int -nvkm_ioctl_wr(struct nouveau_handle *handle, void *data, u32 size) +nvkm_ioctl_wr(struct nvkm_handle *handle, void *data, u32 size) { - struct nouveau_object *object = handle->object; - struct nouveau_ofuncs *ofuncs = object->oclass->ofuncs; + struct nvkm_object *object = handle->object; + struct nvkm_ofuncs *ofuncs = object->oclass->ofuncs; union { struct nvif_ioctl_wr_v0 v0; } *args = data; @@ -310,10 +306,10 @@ nvkm_ioctl_wr(struct nouveau_handle *handle, void *data, u32 size) } static int -nvkm_ioctl_map(struct nouveau_handle *handle, void *data, u32 size) +nvkm_ioctl_map(struct nvkm_handle *handle, void *data, u32 size) { - struct nouveau_object *object = handle->object; - struct nouveau_ofuncs *ofuncs = object->oclass->ofuncs; + struct nvkm_object *object = handle->object; + struct nvkm_ofuncs *ofuncs = object->oclass->ofuncs; union { struct nvif_ioctl_map_v0 v0; } *args = data; @@ -332,9 +328,9 @@ nvkm_ioctl_map(struct nouveau_handle *handle, void *data, u32 size) } static int -nvkm_ioctl_unmap(struct nouveau_handle *handle, void *data, u32 size) +nvkm_ioctl_unmap(struct nvkm_handle *handle, void *data, u32 size) { - struct nouveau_object *object = handle->object; + struct nvkm_object *object = handle->object; union { struct nvif_ioctl_unmap none; } *args = data; @@ -349,10 +345,10 @@ nvkm_ioctl_unmap(struct nouveau_handle *handle, void *data, u32 size) } static int -nvkm_ioctl_ntfy_new(struct nouveau_handle *handle, void *data, u32 size) +nvkm_ioctl_ntfy_new(struct nvkm_handle *handle, void *data, u32 size) { - struct nouveau_object *object = handle->object; - struct nouveau_ofuncs *ofuncs = object->oclass->ofuncs; + struct nvkm_object *object = handle->object; + struct nvkm_ofuncs *ofuncs = object->oclass->ofuncs; union { struct nvif_ioctl_ntfy_new_v0 v0; } *args = data; @@ -378,10 +374,10 @@ nvkm_ioctl_ntfy_new(struct nouveau_handle *handle, void *data, u32 size) } static int -nvkm_ioctl_ntfy_del(struct nouveau_handle *handle, void *data, u32 size) +nvkm_ioctl_ntfy_del(struct nvkm_handle *handle, void *data, u32 size) { - struct nouveau_client *client = nouveau_client(handle->object); - struct nouveau_object *object = handle->object; + struct nvkm_client *client = nvkm_client(handle->object); + struct nvkm_object *object = handle->object; union { struct nvif_ioctl_ntfy_del_v0 v0; } *args = data; @@ -398,10 +394,10 @@ nvkm_ioctl_ntfy_del(struct nouveau_handle *handle, void *data, u32 size) } static int -nvkm_ioctl_ntfy_get(struct nouveau_handle *handle, void *data, u32 size) +nvkm_ioctl_ntfy_get(struct nvkm_handle *handle, void *data, u32 size) { - struct nouveau_client *client = nouveau_client(handle->object); - struct nouveau_object *object = handle->object; + struct nvkm_client *client = nvkm_client(handle->object); + struct nvkm_object *object = handle->object; union { struct nvif_ioctl_ntfy_get_v0 v0; } *args = data; @@ -418,10 +414,10 @@ nvkm_ioctl_ntfy_get(struct nouveau_handle *handle, void *data, u32 size) } static int -nvkm_ioctl_ntfy_put(struct nouveau_handle *handle, void *data, u32 size) +nvkm_ioctl_ntfy_put(struct nvkm_handle *handle, void *data, u32 size) { - struct nouveau_client *client = nouveau_client(handle->object); - struct nouveau_object *object = handle->object; + struct nvkm_client *client = nvkm_client(handle->object); + struct nvkm_object *object = handle->object; union { struct nvif_ioctl_ntfy_put_v0 v0; } *args = data; @@ -439,7 +435,7 @@ nvkm_ioctl_ntfy_put(struct nouveau_handle *handle, void *data, u32 size) static struct { int version; - int (*func)(struct nouveau_handle *, void *, u32); + int (*func)(struct nvkm_handle *, void *, u32); } nvkm_ioctl_v0[] = { { 0x00, nvkm_ioctl_nop }, @@ -458,13 +454,12 @@ nvkm_ioctl_v0[] = { }; static int -nvkm_ioctl_path(struct nouveau_handle *parent, u32 type, u32 nr, - u32 *path, void *data, u32 size, - u8 owner, u8 *route, u64 *token) +nvkm_ioctl_path(struct nvkm_handle *parent, u32 type, u32 nr, u32 *path, + void *data, u32 size, u8 owner, u8 *route, u64 *token) { - struct nouveau_handle *handle = parent; - struct nouveau_namedb *namedb; - struct nouveau_object *object; + struct nvkm_handle *handle = parent; + struct nvkm_namedb *namedb; + struct nvkm_object *object; int ret; while ((object = parent->object), nr--) { @@ -475,16 +470,15 @@ nvkm_ioctl_path(struct nouveau_handle *parent, u32 type, u32 nr, } if (!(namedb = (void *)nv_pclass(object, NV_NAMEDB_CLASS)) || - !(handle = nouveau_namedb_get(namedb, path[nr]))) { + !(handle = nvkm_namedb_get(namedb, path[nr]))) { nv_debug(object, "handle 0x%08x not found\n", path[nr]); return -ENOENT; } - nouveau_namedb_put(handle); + nvkm_namedb_put(handle); parent = handle; } - if (owner != NVIF_IOCTL_V0_OWNER_ANY && - owner != handle->route) { + if (owner != NVIF_IOCTL_V0_OWNER_ANY && owner != handle->route) { nv_ioctl(object, "object route != owner\n"); return -EACCES; } @@ -492,16 +486,15 @@ nvkm_ioctl_path(struct nouveau_handle *parent, u32 type, u32 nr, *token = handle->token; if (ret = -EINVAL, type < ARRAY_SIZE(nvkm_ioctl_v0)) { - if (nvkm_ioctl_v0[type].version == 0) { + if (nvkm_ioctl_v0[type].version == 0) ret = nvkm_ioctl_v0[type].func(handle, data, size); - } } return ret; } int -nvkm_ioctl(struct nouveau_client *client, bool supervisor, +nvkm_ioctl(struct nvkm_client *client, bool supervisor, void *data, u32 size, void **hack) { union { @@ -519,7 +512,7 @@ nvkm_ioctl(struct nouveau_client *client, bool supervisor, ret = nvkm_ioctl_path(client->root, args->v0.type, args->v0.path_nr, args->v0.path, data, size, args->v0.owner, - &args->v0.route, &args->v0.token); + &args->v0.route, &args->v0.token); } nv_ioctl(client, "return %d\n", ret); @@ -527,6 +520,7 @@ nvkm_ioctl(struct nouveau_client *client, bool supervisor, *hack = client->data; client->data = NULL; } + client->super = false; return ret; } diff --git a/drivers/gpu/drm/nouveau/nvkm/core/mm.c b/drivers/gpu/drm/nouveau/nvkm/core/mm.c index b4f5db6..7f458df 100644 --- a/drivers/gpu/drm/nouveau/nvkm/core/mm.c +++ b/drivers/gpu/drm/nouveau/nvkm/core/mm.c @@ -21,39 +21,37 @@ * * Authors: Ben Skeggs */ +#include -#include "core/os.h" -#include "core/mm.h" - -#define node(root, dir) ((root)->nl_entry.dir == &mm->nodes) ? NULL : \ - list_entry((root)->nl_entry.dir, struct nouveau_mm_node, nl_entry) +#define node(root, dir) ((root)->nl_entry.dir == &mm->nodes) ? NULL : \ + list_entry((root)->nl_entry.dir, struct nvkm_mm_node, nl_entry) static void -nouveau_mm_dump(struct nouveau_mm *mm, const char *header) +nvkm_mm_dump(struct nvkm_mm *mm, const char *header) { - struct nouveau_mm_node *node; + struct nvkm_mm_node *node; - printk(KERN_ERR "nouveau: %s\n", header); - printk(KERN_ERR "nouveau: node list:\n"); + printk(KERN_ERR "nvkm: %s\n", header); + printk(KERN_ERR "nvkm: node list:\n"); list_for_each_entry(node, &mm->nodes, nl_entry) { - printk(KERN_ERR "nouveau: \t%08x %08x %d\n", + printk(KERN_ERR "nvkm: \t%08x %08x %d\n", node->offset, node->length, node->type); } - printk(KERN_ERR "nouveau: free list:\n"); + printk(KERN_ERR "nvkm: free list:\n"); list_for_each_entry(node, &mm->free, fl_entry) { - printk(KERN_ERR "nouveau: \t%08x %08x %d\n", + printk(KERN_ERR "nvkm: \t%08x %08x %d\n", node->offset, node->length, node->type); } } void -nouveau_mm_free(struct nouveau_mm *mm, struct nouveau_mm_node **pthis) +nvkm_mm_free(struct nvkm_mm *mm, struct nvkm_mm_node **pthis) { - struct nouveau_mm_node *this = *pthis; + struct nvkm_mm_node *this = *pthis; if (this) { - struct nouveau_mm_node *prev = node(this, prev); - struct nouveau_mm_node *next = node(this, next); + struct nvkm_mm_node *prev = node(this, prev); + struct nvkm_mm_node *next = node(this, next); if (prev && prev->type == NVKM_MM_TYPE_NONE) { prev->length += this->length; @@ -84,10 +82,10 @@ nouveau_mm_free(struct nouveau_mm *mm, struct nouveau_mm_node **pthis) *pthis = NULL; } -static struct nouveau_mm_node * -region_head(struct nouveau_mm *mm, struct nouveau_mm_node *a, u32 size) +static struct nvkm_mm_node * +region_head(struct nvkm_mm *mm, struct nvkm_mm_node *a, u32 size) { - struct nouveau_mm_node *b; + struct nvkm_mm_node *b; if (a->length == size) return a; @@ -105,14 +103,15 @@ region_head(struct nouveau_mm *mm, struct nouveau_mm_node *a, u32 size) list_add_tail(&b->nl_entry, &a->nl_entry); if (b->type == NVKM_MM_TYPE_NONE) list_add_tail(&b->fl_entry, &a->fl_entry); + return b; } int -nouveau_mm_head(struct nouveau_mm *mm, u8 heap, u8 type, u32 size_max, - u32 size_min, u32 align, struct nouveau_mm_node **pnode) +nvkm_mm_head(struct nvkm_mm *mm, u8 heap, u8 type, u32 size_max, u32 size_min, + u32 align, struct nvkm_mm_node **pnode) { - struct nouveau_mm_node *prev, *this, *next; + struct nvkm_mm_node *prev, *this, *next; u32 mask = align - 1; u32 splitoff; u32 s, e; @@ -157,10 +156,10 @@ nouveau_mm_head(struct nouveau_mm *mm, u8 heap, u8 type, u32 size_max, return -ENOSPC; } -static struct nouveau_mm_node * -region_tail(struct nouveau_mm *mm, struct nouveau_mm_node *a, u32 size) +static struct nvkm_mm_node * +region_tail(struct nvkm_mm *mm, struct nvkm_mm_node *a, u32 size) { - struct nouveau_mm_node *b; + struct nvkm_mm_node *b; if (a->length == size) return a; @@ -178,14 +177,15 @@ region_tail(struct nouveau_mm *mm, struct nouveau_mm_node *a, u32 size) list_add(&b->nl_entry, &a->nl_entry); if (b->type == NVKM_MM_TYPE_NONE) list_add(&b->fl_entry, &a->fl_entry); + return b; } int -nouveau_mm_tail(struct nouveau_mm *mm, u8 heap, u8 type, u32 size_max, - u32 size_min, u32 align, struct nouveau_mm_node **pnode) +nvkm_mm_tail(struct nvkm_mm *mm, u8 heap, u8 type, u32 size_max, u32 size_min, + u32 align, struct nvkm_mm_node **pnode) { - struct nouveau_mm_node *prev, *this, *next; + struct nvkm_mm_node *prev, *this, *next; u32 mask = align - 1; BUG_ON(type == NVKM_MM_TYPE_NONE || type == NVKM_MM_TYPE_HOLE); @@ -235,12 +235,12 @@ nouveau_mm_tail(struct nouveau_mm *mm, u8 heap, u8 type, u32 size_max, } int -nouveau_mm_init(struct nouveau_mm *mm, u32 offset, u32 length, u32 block) +nvkm_mm_init(struct nvkm_mm *mm, u32 offset, u32 length, u32 block) { - struct nouveau_mm_node *node, *prev; + struct nvkm_mm_node *node, *prev; u32 next; - if (nouveau_mm_initialised(mm)) { + if (nvkm_mm_initialised(mm)) { prev = list_last_entry(&mm->nodes, typeof(*node), nl_entry); next = prev->offset + prev->length; if (next != offset) { @@ -277,18 +277,18 @@ nouveau_mm_init(struct nouveau_mm *mm, u32 offset, u32 length, u32 block) } int -nouveau_mm_fini(struct nouveau_mm *mm) +nvkm_mm_fini(struct nvkm_mm *mm) { - struct nouveau_mm_node *node, *temp; + struct nvkm_mm_node *node, *temp; int nodes = 0; - if (!nouveau_mm_initialised(mm)) + if (!nvkm_mm_initialised(mm)) return 0; list_for_each_entry(node, &mm->nodes, nl_entry) { if (node->type != NVKM_MM_TYPE_HOLE) { if (++nodes > mm->heap_nodes) { - nouveau_mm_dump(mm, "mm not clean!"); + nvkm_mm_dump(mm, "mm not clean!"); return -EBUSY; } } @@ -298,6 +298,7 @@ nouveau_mm_fini(struct nouveau_mm *mm) list_del(&node->nl_entry); kfree(node); } + mm->heap_nodes = 0; return 0; } diff --git a/drivers/gpu/drm/nouveau/nvkm/core/namedb.c b/drivers/gpu/drm/nouveau/nvkm/core/namedb.c index 0594a59..6400767 100644 --- a/drivers/gpu/drm/nouveau/nvkm/core/namedb.c +++ b/drivers/gpu/drm/nouveau/nvkm/core/namedb.c @@ -21,16 +21,14 @@ * * Authors: Ben Skeggs */ - -#include #include -#include #include +#include -static struct nouveau_handle * -nouveau_namedb_lookup(struct nouveau_namedb *namedb, u32 name) +static struct nvkm_handle * +nvkm_namedb_lookup(struct nvkm_namedb *namedb, u32 name) { - struct nouveau_handle *handle; + struct nvkm_handle *handle; list_for_each_entry(handle, &namedb->list, node) { if (handle->name == name) @@ -40,10 +38,10 @@ nouveau_namedb_lookup(struct nouveau_namedb *namedb, u32 name) return NULL; } -static struct nouveau_handle * -nouveau_namedb_lookup_class(struct nouveau_namedb *namedb, u16 oclass) +static struct nvkm_handle * +nvkm_namedb_lookup_class(struct nvkm_namedb *namedb, u16 oclass) { - struct nouveau_handle *handle; + struct nvkm_handle *handle; list_for_each_entry(handle, &namedb->list, node) { if (nv_mclass(handle->object) == oclass) @@ -53,10 +51,10 @@ nouveau_namedb_lookup_class(struct nouveau_namedb *namedb, u16 oclass) return NULL; } -static struct nouveau_handle * -nouveau_namedb_lookup_vinst(struct nouveau_namedb *namedb, u64 vinst) +static struct nvkm_handle * +nvkm_namedb_lookup_vinst(struct nvkm_namedb *namedb, u64 vinst) { - struct nouveau_handle *handle; + struct nvkm_handle *handle; list_for_each_entry(handle, &namedb->list, node) { if (nv_iclass(handle->object, NV_GPUOBJ_CLASS)) { @@ -68,10 +66,10 @@ nouveau_namedb_lookup_vinst(struct nouveau_namedb *namedb, u64 vinst) return NULL; } -static struct nouveau_handle * -nouveau_namedb_lookup_cinst(struct nouveau_namedb *namedb, u32 cinst) +static struct nvkm_handle * +nvkm_namedb_lookup_cinst(struct nvkm_namedb *namedb, u32 cinst) { - struct nouveau_handle *handle; + struct nvkm_handle *handle; list_for_each_entry(handle, &namedb->list, node) { if (nv_iclass(handle->object, NV_GPUOBJ_CLASS)) { @@ -85,14 +83,14 @@ nouveau_namedb_lookup_cinst(struct nouveau_namedb *namedb, u32 cinst) } int -nouveau_namedb_insert(struct nouveau_namedb *namedb, u32 name, - struct nouveau_object *object, - struct nouveau_handle *handle) +nvkm_namedb_insert(struct nvkm_namedb *namedb, u32 name, + struct nvkm_object *object, + struct nvkm_handle *handle) { int ret = -EEXIST; write_lock_irq(&namedb->lock); - if (!nouveau_namedb_lookup(namedb, name)) { - nouveau_object_ref(object, &handle->object); + if (!nvkm_namedb_lookup(namedb, name)) { + nvkm_object_ref(object, &handle->object); handle->namedb = namedb; list_add(&handle->node, &namedb->list); ret = 0; @@ -102,80 +100,79 @@ nouveau_namedb_insert(struct nouveau_namedb *namedb, u32 name, } void -nouveau_namedb_remove(struct nouveau_handle *handle) +nvkm_namedb_remove(struct nvkm_handle *handle) { - struct nouveau_namedb *namedb = handle->namedb; - struct nouveau_object *object = handle->object; + struct nvkm_namedb *namedb = handle->namedb; + struct nvkm_object *object = handle->object; write_lock_irq(&namedb->lock); list_del(&handle->node); write_unlock_irq(&namedb->lock); - nouveau_object_ref(NULL, &object); + nvkm_object_ref(NULL, &object); } -struct nouveau_handle * -nouveau_namedb_get(struct nouveau_namedb *namedb, u32 name) +struct nvkm_handle * +nvkm_namedb_get(struct nvkm_namedb *namedb, u32 name) { - struct nouveau_handle *handle; + struct nvkm_handle *handle; read_lock(&namedb->lock); - handle = nouveau_namedb_lookup(namedb, name); + handle = nvkm_namedb_lookup(namedb, name); if (handle == NULL) read_unlock(&namedb->lock); return handle; } -struct nouveau_handle * -nouveau_namedb_get_class(struct nouveau_namedb *namedb, u16 oclass) +struct nvkm_handle * +nvkm_namedb_get_class(struct nvkm_namedb *namedb, u16 oclass) { - struct nouveau_handle *handle; + struct nvkm_handle *handle; read_lock(&namedb->lock); - handle = nouveau_namedb_lookup_class(namedb, oclass); + handle = nvkm_namedb_lookup_class(namedb, oclass); if (handle == NULL) read_unlock(&namedb->lock); return handle; } -struct nouveau_handle * -nouveau_namedb_get_vinst(struct nouveau_namedb *namedb, u64 vinst) +struct nvkm_handle * +nvkm_namedb_get_vinst(struct nvkm_namedb *namedb, u64 vinst) { - struct nouveau_handle *handle; + struct nvkm_handle *handle; read_lock(&namedb->lock); - handle = nouveau_namedb_lookup_vinst(namedb, vinst); + handle = nvkm_namedb_lookup_vinst(namedb, vinst); if (handle == NULL) read_unlock(&namedb->lock); return handle; } -struct nouveau_handle * -nouveau_namedb_get_cinst(struct nouveau_namedb *namedb, u32 cinst) +struct nvkm_handle * +nvkm_namedb_get_cinst(struct nvkm_namedb *namedb, u32 cinst) { - struct nouveau_handle *handle; + struct nvkm_handle *handle; read_lock(&namedb->lock); - handle = nouveau_namedb_lookup_cinst(namedb, cinst); + handle = nvkm_namedb_lookup_cinst(namedb, cinst); if (handle == NULL) read_unlock(&namedb->lock); return handle; } void -nouveau_namedb_put(struct nouveau_handle *handle) +nvkm_namedb_put(struct nvkm_handle *handle) { if (handle) read_unlock(&handle->namedb->lock); } int -nouveau_namedb_create_(struct nouveau_object *parent, - struct nouveau_object *engine, - struct nouveau_oclass *oclass, u32 pclass, - struct nouveau_oclass *sclass, u64 engcls, - int length, void **pobject) +nvkm_namedb_create_(struct nvkm_object *parent, struct nvkm_object *engine, + struct nvkm_oclass *oclass, u32 pclass, + struct nvkm_oclass *sclass, u64 engcls, + int length, void **pobject) { - struct nouveau_namedb *namedb; + struct nvkm_namedb *namedb; int ret; - ret = nouveau_parent_create_(parent, engine, oclass, pclass | - NV_NAMEDB_CLASS, sclass, engcls, - length, pobject); + ret = nvkm_parent_create_(parent, engine, oclass, pclass | + NV_NAMEDB_CLASS, sclass, engcls, + length, pobject); namedb = *pobject; if (ret) return ret; @@ -186,15 +183,14 @@ nouveau_namedb_create_(struct nouveau_object *parent, } int -_nouveau_namedb_ctor(struct nouveau_object *parent, - struct nouveau_object *engine, - struct nouveau_oclass *oclass, void *data, u32 size, - struct nouveau_object **pobject) +_nvkm_namedb_ctor(struct nvkm_object *parent, struct nvkm_object *engine, + struct nvkm_oclass *oclass, void *data, u32 size, + struct nvkm_object **pobject) { - struct nouveau_namedb *object; + struct nvkm_namedb *object; int ret; - ret = nouveau_namedb_create(parent, engine, oclass, 0, NULL, 0, &object); + ret = nvkm_namedb_create(parent, engine, oclass, 0, NULL, 0, &object); *pobject = nv_object(object); if (ret) return ret; diff --git a/drivers/gpu/drm/nouveau/nvkm/core/notify.c b/drivers/gpu/drm/nouveau/nvkm/core/notify.c index 839a325..023610d 100644 --- a/drivers/gpu/drm/nouveau/nvkm/core/notify.c +++ b/drivers/gpu/drm/nouveau/nvkm/core/notify.c @@ -21,13 +21,8 @@ * * Authors: Ben Skeggs */ - -#include -#include #include - -#include -#include +#include static inline void nvkm_notify_put_locked(struct nvkm_notify *notify) @@ -134,7 +129,7 @@ nvkm_notify_fini(struct nvkm_notify *notify) } int -nvkm_notify_init(struct nouveau_object *object, struct nvkm_event *event, +nvkm_notify_init(struct nvkm_object *object, struct nvkm_event *event, int (*func)(struct nvkm_notify *), bool work, void *data, u32 size, u32 reply, struct nvkm_notify *notify) diff --git a/drivers/gpu/drm/nouveau/nvkm/core/object.c b/drivers/gpu/drm/nouveau/nvkm/core/object.c index b160860..979f362 100644 --- a/drivers/gpu/drm/nouveau/nvkm/core/object.c +++ b/drivers/gpu/drm/nouveau/nvkm/core/object.c @@ -21,36 +21,34 @@ * * Authors: Ben Skeggs */ - #include #include -#ifdef NOUVEAU_OBJECT_MAGIC +#ifdef NVKM_OBJECT_MAGIC static struct list_head _objlist = LIST_HEAD_INIT(_objlist); static DEFINE_SPINLOCK(_objlist_lock); #endif int -nouveau_object_create_(struct nouveau_object *parent, - struct nouveau_object *engine, - struct nouveau_oclass *oclass, u32 pclass, - int size, void **pobject) +nvkm_object_create_(struct nvkm_object *parent, struct nvkm_object *engine, + struct nvkm_oclass *oclass, u32 pclass, + int size, void **pobject) { - struct nouveau_object *object; + struct nvkm_object *object; object = *pobject = kzalloc(size, GFP_KERNEL); if (!object) return -ENOMEM; - nouveau_object_ref(parent, &object->parent); - nouveau_object_ref(engine, (struct nouveau_object **)&object->engine); + nvkm_object_ref(parent, &object->parent); + nvkm_object_ref(engine, (struct nvkm_object **)&object->engine); object->oclass = oclass; object->oclass->handle |= pclass; atomic_set(&object->refcount, 1); atomic_set(&object->usecount, 0); -#ifdef NOUVEAU_OBJECT_MAGIC - object->_magic = NOUVEAU_OBJECT_MAGIC; +#ifdef NVKM_OBJECT_MAGIC + object->_magic = NVKM_OBJECT_MAGIC; spin_lock(&_objlist_lock); list_add(&object->list, &_objlist); spin_unlock(&_objlist_lock); @@ -59,57 +57,55 @@ nouveau_object_create_(struct nouveau_object *parent, } int -_nouveau_object_ctor(struct nouveau_object *parent, - struct nouveau_object *engine, - struct nouveau_oclass *oclass, void *data, u32 size, - struct nouveau_object **pobject) +_nvkm_object_ctor(struct nvkm_object *parent, struct nvkm_object *engine, + struct nvkm_oclass *oclass, void *data, u32 size, + struct nvkm_object **pobject) { if (size != 0) return -ENOSYS; - return nouveau_object_create(parent, engine, oclass, 0, pobject); + return nvkm_object_create(parent, engine, oclass, 0, pobject); } void -nouveau_object_destroy(struct nouveau_object *object) +nvkm_object_destroy(struct nvkm_object *object) { -#ifdef NOUVEAU_OBJECT_MAGIC +#ifdef NVKM_OBJECT_MAGIC spin_lock(&_objlist_lock); list_del(&object->list); spin_unlock(&_objlist_lock); #endif - nouveau_object_ref(NULL, (struct nouveau_object **)&object->engine); - nouveau_object_ref(NULL, &object->parent); + nvkm_object_ref(NULL, (struct nvkm_object **)&object->engine); + nvkm_object_ref(NULL, &object->parent); kfree(object); } int -nouveau_object_init(struct nouveau_object *object) +nvkm_object_init(struct nvkm_object *object) { return 0; } int -nouveau_object_fini(struct nouveau_object *object, bool suspend) +nvkm_object_fini(struct nvkm_object *object, bool suspend) { return 0; } -struct nouveau_ofuncs -nouveau_object_ofuncs = { - .ctor = _nouveau_object_ctor, - .dtor = nouveau_object_destroy, - .init = nouveau_object_init, - .fini = nouveau_object_fini, +struct nvkm_ofuncs +nvkm_object_ofuncs = { + .ctor = _nvkm_object_ctor, + .dtor = nvkm_object_destroy, + .init = nvkm_object_init, + .fini = nvkm_object_fini, }; int -nouveau_object_ctor(struct nouveau_object *parent, - struct nouveau_object *engine, - struct nouveau_oclass *oclass, void *data, u32 size, - struct nouveau_object **pobject) +nvkm_object_ctor(struct nvkm_object *parent, struct nvkm_object *engine, + struct nvkm_oclass *oclass, void *data, u32 size, + struct nvkm_object **pobject) { - struct nouveau_ofuncs *ofuncs = oclass->ofuncs; - struct nouveau_object *object = NULL; + struct nvkm_ofuncs *ofuncs = oclass->ofuncs; + struct nvkm_object *object = NULL; int ret; ret = ofuncs->ctor(parent, engine, oclass, data, size, &object); @@ -137,14 +133,14 @@ nouveau_object_ctor(struct nouveau_object *parent, } static void -nouveau_object_dtor(struct nouveau_object *object) +nvkm_object_dtor(struct nvkm_object *object) { nv_trace(object, "destroying\n"); nv_ofuncs(object)->dtor(object); } void -nouveau_object_ref(struct nouveau_object *obj, struct nouveau_object **ref) +nvkm_object_ref(struct nvkm_object *obj, struct nvkm_object **ref) { if (obj) { atomic_inc(&obj->refcount); @@ -155,14 +151,14 @@ nouveau_object_ref(struct nouveau_object *obj, struct nouveau_object **ref) int dead = atomic_dec_and_test(&(*ref)->refcount); nv_trace(*ref, "dec() == %d\n", atomic_read(&(*ref)->refcount)); if (dead) - nouveau_object_dtor(*ref); + nvkm_object_dtor(*ref); } *ref = obj; } int -nouveau_object_inc(struct nouveau_object *object) +nvkm_object_inc(struct nvkm_object *object) { int ref = atomic_add_return(1, &object->usecount); int ret; @@ -173,7 +169,7 @@ nouveau_object_inc(struct nouveau_object *object) nv_trace(object, "initialising...\n"); if (object->parent) { - ret = nouveau_object_inc(object->parent); + ret = nvkm_object_inc(object->parent); if (ret) { nv_error(object, "parent failed, %d\n", ret); goto fail_parent; @@ -182,7 +178,7 @@ nouveau_object_inc(struct nouveau_object *object) if (object->engine) { mutex_lock(&nv_subdev(object->engine)->mutex); - ret = nouveau_object_inc(&object->engine->subdev.object); + ret = nvkm_object_inc(&object->engine->subdev.object); mutex_unlock(&nv_subdev(object->engine)->mutex); if (ret) { nv_error(object, "engine failed, %d\n", ret); @@ -203,19 +199,19 @@ nouveau_object_inc(struct nouveau_object *object) fail_self: if (object->engine) { mutex_lock(&nv_subdev(object->engine)->mutex); - nouveau_object_dec(&object->engine->subdev.object, false); + nvkm_object_dec(&object->engine->subdev.object, false); mutex_unlock(&nv_subdev(object->engine)->mutex); } fail_engine: if (object->parent) - nouveau_object_dec(object->parent, false); + nvkm_object_dec(object->parent, false); fail_parent: atomic_dec(&object->usecount); return ret; } static int -nouveau_object_decf(struct nouveau_object *object) +nvkm_object_decf(struct nvkm_object *object) { int ret; @@ -228,19 +224,19 @@ nouveau_object_decf(struct nouveau_object *object) if (object->engine) { mutex_lock(&nv_subdev(object->engine)->mutex); - nouveau_object_dec(&object->engine->subdev.object, false); + nvkm_object_dec(&object->engine->subdev.object, false); mutex_unlock(&nv_subdev(object->engine)->mutex); } if (object->parent) - nouveau_object_dec(object->parent, false); + nvkm_object_dec(object->parent, false); nv_trace(object, "stopped\n"); return 0; } static int -nouveau_object_decs(struct nouveau_object *object) +nvkm_object_decs(struct nvkm_object *object) { int ret, rret; @@ -255,7 +251,7 @@ nouveau_object_decs(struct nouveau_object *object) if (object->engine) { mutex_lock(&nv_subdev(object->engine)->mutex); - ret = nouveau_object_dec(&object->engine->subdev.object, true); + ret = nvkm_object_dec(&object->engine->subdev.object, true); mutex_unlock(&nv_subdev(object->engine)->mutex); if (ret) { nv_warn(object, "engine failed suspend, %d\n", ret); @@ -264,7 +260,7 @@ nouveau_object_decs(struct nouveau_object *object) } if (object->parent) { - ret = nouveau_object_dec(object->parent, true); + ret = nvkm_object_dec(object->parent, true); if (ret) { nv_warn(object, "parent failed suspend, %d\n", ret); goto fail_parent; @@ -277,7 +273,7 @@ nouveau_object_decs(struct nouveau_object *object) fail_parent: if (object->engine) { mutex_lock(&nv_subdev(object->engine)->mutex); - rret = nouveau_object_inc(&object->engine->subdev.object); + rret = nvkm_object_inc(&object->engine->subdev.object); mutex_unlock(&nv_subdev(object->engine)->mutex); if (rret) nv_fatal(object, "engine failed to reinit, %d\n", rret); @@ -292,7 +288,7 @@ fail_engine: } int -nouveau_object_dec(struct nouveau_object *object, bool suspend) +nvkm_object_dec(struct nvkm_object *object, bool suspend) { int ref = atomic_add_return(-1, &object->usecount); int ret; @@ -301,9 +297,9 @@ nouveau_object_dec(struct nouveau_object *object, bool suspend) if (ref == 0) { if (suspend) - ret = nouveau_object_decs(object); + ret = nvkm_object_decs(object); else - ret = nouveau_object_decf(object); + ret = nvkm_object_decf(object); if (ret) { atomic_inc(&object->usecount); @@ -315,10 +311,10 @@ nouveau_object_dec(struct nouveau_object *object, bool suspend) } void -nouveau_object_debug(void) +nvkm_object_debug(void) { -#ifdef NOUVEAU_OBJECT_MAGIC - struct nouveau_object *object; +#ifdef NVKM_OBJECT_MAGIC + struct nvkm_object *object; if (!list_empty(&_objlist)) { nv_fatal(NULL, "*******************************************\n"); nv_fatal(NULL, "* AIIIII! object(s) still exist!!!\n"); diff --git a/drivers/gpu/drm/nouveau/nvkm/core/option.c b/drivers/gpu/drm/nouveau/nvkm/core/option.c index 9f6fcc5..19d153f 100644 --- a/drivers/gpu/drm/nouveau/nvkm/core/option.c +++ b/drivers/gpu/drm/nouveau/nvkm/core/option.c @@ -21,12 +21,11 @@ * * Authors: Ben Skeggs */ - #include #include const char * -nouveau_stropt(const char *optstr, const char *opt, int *arglen) +nvkm_stropt(const char *optstr, const char *opt, int *arglen) { while (optstr && *optstr != '\0') { int len = strcspn(optstr, ",="); @@ -52,11 +51,11 @@ nouveau_stropt(const char *optstr, const char *opt, int *arglen) } bool -nouveau_boolopt(const char *optstr, const char *opt, bool value) +nvkm_boolopt(const char *optstr, const char *opt, bool value) { int arglen; - optstr = nouveau_stropt(optstr, opt, &arglen); + optstr = nvkm_stropt(optstr, opt, &arglen); if (optstr) { if (!strncasecmpz(optstr, "0", arglen) || !strncasecmpz(optstr, "no", arglen) || @@ -75,7 +74,7 @@ nouveau_boolopt(const char *optstr, const char *opt, bool value) } int -nouveau_dbgopt(const char *optstr, const char *sub) +nvkm_dbgopt(const char *optstr, const char *sub) { int mode = 1, level = CONFIG_NOUVEAU_DEBUG_DEFAULT; diff --git a/drivers/gpu/drm/nouveau/nvkm/core/parent.c b/drivers/gpu/drm/nouveau/nvkm/core/parent.c index 1f28fa12..dd56cd1 100644 --- a/drivers/gpu/drm/nouveau/nvkm/core/parent.c +++ b/drivers/gpu/drm/nouveau/nvkm/core/parent.c @@ -21,19 +21,18 @@ * * Authors: Ben Skeggs */ - -#include #include #include +#include int -nouveau_parent_sclass(struct nouveau_object *parent, u16 handle, - struct nouveau_object **pengine, - struct nouveau_oclass **poclass) +nvkm_parent_sclass(struct nvkm_object *parent, u16 handle, + struct nvkm_object **pengine, + struct nvkm_oclass **poclass) { - struct nouveau_sclass *sclass; - struct nouveau_engine *engine; - struct nouveau_oclass *oclass; + struct nvkm_sclass *sclass; + struct nvkm_engine *engine; + struct nvkm_oclass *oclass; u64 mask; sclass = nv_parent(parent)->sclass; @@ -54,7 +53,7 @@ nouveau_parent_sclass(struct nouveau_object *parent, u16 handle, if (nv_iclass(parent, NV_CLIENT_CLASS)) engine = nv_engine(nv_client(parent)->device); else - engine = nouveau_engine(parent, i); + engine = nvkm_engine(parent, i); if (engine) { oclass = engine->sclass; @@ -75,11 +74,11 @@ nouveau_parent_sclass(struct nouveau_object *parent, u16 handle, } int -nouveau_parent_lclass(struct nouveau_object *parent, u32 *lclass, int size) +nvkm_parent_lclass(struct nvkm_object *parent, u32 *lclass, int size) { - struct nouveau_sclass *sclass; - struct nouveau_engine *engine; - struct nouveau_oclass *oclass; + struct nvkm_sclass *sclass; + struct nvkm_engine *engine; + struct nvkm_oclass *oclass; int nr = -1, i; u64 mask; @@ -92,7 +91,7 @@ nouveau_parent_lclass(struct nouveau_object *parent, u32 *lclass, int size) mask = nv_parent(parent)->engine; while (i = __ffs64(mask), mask) { - engine = nouveau_engine(parent, i); + engine = nvkm_engine(parent, i); if (engine && (oclass = engine->sclass)) { while (oclass->ofuncs) { if (++nr < size) @@ -108,18 +107,17 @@ nouveau_parent_lclass(struct nouveau_object *parent, u32 *lclass, int size) } int -nouveau_parent_create_(struct nouveau_object *parent, - struct nouveau_object *engine, - struct nouveau_oclass *oclass, u32 pclass, - struct nouveau_oclass *sclass, u64 engcls, - int size, void **pobject) +nvkm_parent_create_(struct nvkm_object *parent, struct nvkm_object *engine, + struct nvkm_oclass *oclass, u32 pclass, + struct nvkm_oclass *sclass, u64 engcls, + int size, void **pobject) { - struct nouveau_parent *object; - struct nouveau_sclass *nclass; + struct nvkm_parent *object; + struct nvkm_sclass *nclass; int ret; - ret = nouveau_object_create_(parent, engine, oclass, pclass | - NV_PARENT_CLASS, size, pobject); + ret = nvkm_object_create_(parent, engine, oclass, pclass | + NV_PARENT_CLASS, size, pobject); object = *pobject; if (ret) return ret; @@ -141,21 +139,21 @@ nouveau_parent_create_(struct nouveau_object *parent, } void -nouveau_parent_destroy(struct nouveau_parent *parent) +nvkm_parent_destroy(struct nvkm_parent *parent) { - struct nouveau_sclass *sclass; + struct nvkm_sclass *sclass; while ((sclass = parent->sclass)) { parent->sclass = sclass->sclass; kfree(sclass); } - nouveau_object_destroy(&parent->object); + nvkm_object_destroy(&parent->object); } void -_nouveau_parent_dtor(struct nouveau_object *object) +_nvkm_parent_dtor(struct nvkm_object *object) { - nouveau_parent_destroy(nv_parent(object)); + nvkm_parent_destroy(nv_parent(object)); } diff --git a/drivers/gpu/drm/nouveau/nvkm/core/printk.c b/drivers/gpu/drm/nouveau/nvkm/core/printk.c index ed424f9..4a220eb 100644 --- a/drivers/gpu/drm/nouveau/nvkm/core/printk.c +++ b/drivers/gpu/drm/nouveau/nvkm/core/printk.c @@ -21,16 +21,14 @@ * * Authors: Ben Skeggs */ - -#include -#include -#include #include +#include +#include int nv_info_debug_level = NV_DBG_INFO_NORMAL; void -nv_printk_(struct nouveau_object *object, int level, const char *fmt, ...) +nv_printk_(struct nvkm_object *object, int level, const char *fmt, ...) { static const char name[] = { '!', 'E', 'W', ' ', 'D', 'T', 'P', 'S' }; const char *pfx; @@ -60,8 +58,8 @@ nv_printk_(struct nouveau_object *object, int level, const char *fmt, ...) } if (object && !nv_iclass(object, NV_CLIENT_CLASS)) { - struct nouveau_object *device; - struct nouveau_object *subdev; + struct nvkm_object *device; + struct nvkm_object *subdev; char obuf[64], *ofmt = ""; if (object->engine == NULL) { diff --git a/drivers/gpu/drm/nouveau/nvkm/core/ramht.c b/drivers/gpu/drm/nouveau/nvkm/core/ramht.c index 25cd6f2..0a382d0 100644 --- a/drivers/gpu/drm/nouveau/nvkm/core/ramht.c +++ b/drivers/gpu/drm/nouveau/nvkm/core/ramht.c @@ -19,14 +19,12 @@ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ - -#include #include #include static u32 -nouveau_ramht_hash(struct nouveau_ramht *ramht, int chid, u32 handle) +nvkm_ramht_hash(struct nvkm_ramht *ramht, int chid, u32 handle) { u32 hash = 0; @@ -41,13 +39,12 @@ nouveau_ramht_hash(struct nouveau_ramht *ramht, int chid, u32 handle) } int -nouveau_ramht_insert(struct nouveau_ramht *ramht, int chid, - u32 handle, u32 context) +nvkm_ramht_insert(struct nvkm_ramht *ramht, int chid, u32 handle, u32 context) { - struct nouveau_bar *bar = nouveau_bar(ramht); + struct nvkm_bar *bar = nvkm_bar(ramht); u32 co, ho; - co = ho = nouveau_ramht_hash(ramht, chid, handle); + co = ho = nvkm_ramht_hash(ramht, chid, handle); do { if (!nv_ro32(ramht, co + 4)) { nv_wo32(ramht, co + 0, handle); @@ -66,39 +63,39 @@ nouveau_ramht_insert(struct nouveau_ramht *ramht, int chid, } void -nouveau_ramht_remove(struct nouveau_ramht *ramht, int cookie) +nvkm_ramht_remove(struct nvkm_ramht *ramht, int cookie) { - struct nouveau_bar *bar = nouveau_bar(ramht); + struct nvkm_bar *bar = nvkm_bar(ramht); nv_wo32(ramht, cookie + 0, 0x00000000); nv_wo32(ramht, cookie + 4, 0x00000000); if (bar) bar->flush(bar); } -static struct nouveau_oclass -nouveau_ramht_oclass = { +static struct nvkm_oclass +nvkm_ramht_oclass = { .handle = 0x0000abcd, - .ofuncs = &(struct nouveau_ofuncs) { + .ofuncs = &(struct nvkm_ofuncs) { .ctor = NULL, - .dtor = _nouveau_gpuobj_dtor, - .init = _nouveau_gpuobj_init, - .fini = _nouveau_gpuobj_fini, - .rd32 = _nouveau_gpuobj_rd32, - .wr32 = _nouveau_gpuobj_wr32, + .dtor = _nvkm_gpuobj_dtor, + .init = _nvkm_gpuobj_init, + .fini = _nvkm_gpuobj_fini, + .rd32 = _nvkm_gpuobj_rd32, + .wr32 = _nvkm_gpuobj_wr32, }, }; int -nouveau_ramht_new(struct nouveau_object *parent, struct nouveau_object *pargpu, - u32 size, u32 align, struct nouveau_ramht **pramht) +nvkm_ramht_new(struct nvkm_object *parent, struct nvkm_object *pargpu, + u32 size, u32 align, struct nvkm_ramht **pramht) { - struct nouveau_ramht *ramht; + struct nvkm_ramht *ramht; int ret; - ret = nouveau_gpuobj_create(parent, parent->engine ? - &parent->engine->subdev.object : parent, /* engine ? + &parent->engine->subdev.object : parent, /* #include #include #include -struct nouveau_subdev * -nouveau_subdev(void *obj, int idx) +struct nvkm_subdev * +nvkm_subdev(void *obj, int idx) { - struct nouveau_object *object = nv_object(obj); + struct nvkm_object *object = nv_object(obj); while (object && !nv_iclass(object, NV_SUBDEV_CLASS)) object = object->parent; if (object == NULL || nv_subidx(nv_subdev(object)) != idx) @@ -39,7 +37,7 @@ nouveau_subdev(void *obj, int idx) } void -nouveau_subdev_reset(struct nouveau_object *subdev) +nvkm_subdev_reset(struct nvkm_object *subdev) { nv_trace(subdev, "resetting...\n"); nv_ofuncs(subdev)->fini(subdev, false); @@ -47,65 +45,64 @@ nouveau_subdev_reset(struct nouveau_object *subdev) } int -nouveau_subdev_init(struct nouveau_subdev *subdev) +nvkm_subdev_init(struct nvkm_subdev *subdev) { - int ret = nouveau_object_init(&subdev->object); + int ret = nvkm_object_init(&subdev->object); if (ret) return ret; - nouveau_subdev_reset(&subdev->object); + nvkm_subdev_reset(&subdev->object); return 0; } int -_nouveau_subdev_init(struct nouveau_object *object) +_nvkm_subdev_init(struct nvkm_object *object) { - return nouveau_subdev_init(nv_subdev(object)); + return nvkm_subdev_init(nv_subdev(object)); } int -nouveau_subdev_fini(struct nouveau_subdev *subdev, bool suspend) +nvkm_subdev_fini(struct nvkm_subdev *subdev, bool suspend) { if (subdev->unit) { nv_mask(subdev, 0x000200, subdev->unit, 0x00000000); nv_mask(subdev, 0x000200, subdev->unit, subdev->unit); } - return nouveau_object_fini(&subdev->object, suspend); + return nvkm_object_fini(&subdev->object, suspend); } int -_nouveau_subdev_fini(struct nouveau_object *object, bool suspend) +_nvkm_subdev_fini(struct nvkm_object *object, bool suspend) { - return nouveau_subdev_fini(nv_subdev(object), suspend); + return nvkm_subdev_fini(nv_subdev(object), suspend); } void -nouveau_subdev_destroy(struct nouveau_subdev *subdev) +nvkm_subdev_destroy(struct nvkm_subdev *subdev) { int subidx = nv_hclass(subdev) & 0xff; nv_device(subdev)->subdev[subidx] = NULL; - nouveau_object_destroy(&subdev->object); + nvkm_object_destroy(&subdev->object); } void -_nouveau_subdev_dtor(struct nouveau_object *object) +_nvkm_subdev_dtor(struct nvkm_object *object) { - nouveau_subdev_destroy(nv_subdev(object)); + nvkm_subdev_destroy(nv_subdev(object)); } int -nouveau_subdev_create_(struct nouveau_object *parent, - struct nouveau_object *engine, - struct nouveau_oclass *oclass, u32 pclass, - const char *subname, const char *sysname, - int size, void **pobject) +nvkm_subdev_create_(struct nvkm_object *parent, struct nvkm_object *engine, + struct nvkm_oclass *oclass, u32 pclass, + const char *subname, const char *sysname, + int size, void **pobject) { - struct nouveau_subdev *subdev; + struct nvkm_subdev *subdev; int ret; - ret = nouveau_object_create_(parent, engine, oclass, pclass | - NV_SUBDEV_CLASS, size, pobject); + ret = nvkm_object_create_(parent, engine, oclass, pclass | + NV_SUBDEV_CLASS, size, pobject); subdev = *pobject; if (ret) return ret; @@ -114,8 +111,8 @@ nouveau_subdev_create_(struct nouveau_object *parent, subdev->name = subname; if (parent) { - struct nouveau_device *device = nv_device(parent); - subdev->debug = nouveau_dbgopt(device->dbgopt, subname); + struct nvkm_device *device = nv_device(parent); + subdev->debug = nvkm_dbgopt(device->dbgopt, subname); subdev->mmio = nv_subdev(device)->mmio; } diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/bsp/nv84.c b/drivers/gpu/drm/nouveau/nvkm/engine/bsp/nv84.c index 1e8e75c..649922d 100644 --- a/drivers/gpu/drm/nouveau/nvkm/engine/bsp/nv84.c +++ b/drivers/gpu/drm/nouveau/nvkm/engine/bsp/nv84.c @@ -25,6 +25,8 @@ #include #include +#include + /******************************************************************************* * BSP object classes ******************************************************************************/ diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/device/base.c b/drivers/gpu/drm/nouveau/nvkm/engine/device/base.c index 60f5389..ae2ad8b 100644 --- a/drivers/gpu/drm/nouveau/nvkm/engine/device/base.c +++ b/drivers/gpu/drm/nouveau/nvkm/engine/device/base.c @@ -22,6 +22,7 @@ * Authors: Ben Skeggs */ +#include #include #include #include diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/disp/conn.h b/drivers/gpu/drm/nouveau/nvkm/engine/disp/conn.h index a1bf359..4a92d9f 100644 --- a/drivers/gpu/drm/nouveau/nvkm/engine/disp/conn.h +++ b/drivers/gpu/drm/nouveau/nvkm/engine/disp/conn.h @@ -1,8 +1,9 @@ #ifndef __NVKM_DISP_CONN_H__ #define __NVKM_DISP_CONN_H__ - #include "priv.h" +#include + struct nvkm_connector { struct nouveau_object base; struct list_head head; diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/disp/outpdp.h b/drivers/gpu/drm/nouveau/nvkm/engine/disp/outpdp.h index 1fac367..74ef058 100644 --- a/drivers/gpu/drm/nouveau/nvkm/engine/disp/outpdp.h +++ b/drivers/gpu/drm/nouveau/nvkm/engine/disp/outpdp.h @@ -1,6 +1,7 @@ #ifndef __NVKM_DISP_OUTP_DP_H__ #define __NVKM_DISP_OUTP_DP_H__ +#include #include #include diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/falcon.c b/drivers/gpu/drm/nouveau/nvkm/engine/falcon.c index 2914646..f6e9ae9 100644 --- a/drivers/gpu/drm/nouveau/nvkm/engine/falcon.c +++ b/drivers/gpu/drm/nouveau/nvkm/engine/falcon.c @@ -19,14 +19,14 @@ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ - #include + #include void -nouveau_falcon_intr(struct nouveau_subdev *subdev) +nvkm_falcon_intr(struct nvkm_subdev *subdev) { - struct nouveau_falcon *falcon = (void *)subdev; + struct nvkm_falcon *falcon = (void *)subdev; u32 dispatch = nv_ro32(falcon, 0x01c); u32 intr = nv_ro32(falcon, 0x008) & dispatch & ~(dispatch >> 16); @@ -43,16 +43,16 @@ nouveau_falcon_intr(struct nouveau_subdev *subdev) } u32 -_nouveau_falcon_rd32(struct nouveau_object *object, u64 addr) +_nvkm_falcon_rd32(struct nvkm_object *object, u64 addr) { - struct nouveau_falcon *falcon = (void *)object; + struct nvkm_falcon *falcon = (void *)object; return nv_rd32(falcon, falcon->addr + addr); } void -_nouveau_falcon_wr32(struct nouveau_object *object, u64 addr, u32 data) +_nvkm_falcon_wr32(struct nvkm_object *object, u64 addr, u32 data) { - struct nouveau_falcon *falcon = (void *)object; + struct nvkm_falcon *falcon = (void *)object; nv_wr32(falcon, falcon->addr + addr, data); } @@ -67,17 +67,17 @@ vmemdup(const void *src, size_t len) } int -_nouveau_falcon_init(struct nouveau_object *object) +_nvkm_falcon_init(struct nvkm_object *object) { - struct nouveau_device *device = nv_device(object); - struct nouveau_falcon *falcon = (void *)object; + struct nvkm_device *device = nv_device(object); + struct nvkm_falcon *falcon = (void *)object; const struct firmware *fw; char name[32] = "internal"; int ret, i; u32 caps; /* enable engine, and determine its capabilities */ - ret = nouveau_engine_init(&falcon->base); + ret = nvkm_engine_init(&falcon->base); if (ret) return ret; @@ -171,9 +171,8 @@ _nouveau_falcon_init(struct nouveau_object *object) /* ensure any "self-bootstrapping" firmware image is in vram */ if (!falcon->data.data && !falcon->core) { - ret = nouveau_gpuobj_new(object->parent, NULL, - falcon->code.size, 256, 0, - &falcon->core); + ret = nvkm_gpuobj_new(object->parent, NULL, falcon->code.size, + 256, 0, &falcon->core); if (ret) { nv_error(falcon, "core allocation failed, %d\n", ret); return ret; @@ -238,12 +237,12 @@ _nouveau_falcon_init(struct nouveau_object *object) } int -_nouveau_falcon_fini(struct nouveau_object *object, bool suspend) +_nvkm_falcon_fini(struct nvkm_object *object, bool suspend) { - struct nouveau_falcon *falcon = (void *)object; + struct nvkm_falcon *falcon = (void *)object; if (!suspend) { - nouveau_gpuobj_ref(NULL, &falcon->core); + nvkm_gpuobj_ref(NULL, &falcon->core); if (falcon->external) { vfree(falcon->data.data); vfree(falcon->code.data); @@ -254,21 +253,20 @@ _nouveau_falcon_fini(struct nouveau_object *object, bool suspend) nv_mo32(falcon, 0x048, 0x00000003, 0x00000000); nv_wo32(falcon, 0x014, 0xffffffff); - return nouveau_engine_fini(&falcon->base, suspend); + return nvkm_engine_fini(&falcon->base, suspend); } int -nouveau_falcon_create_(struct nouveau_object *parent, - struct nouveau_object *engine, - struct nouveau_oclass *oclass, u32 addr, bool enable, - const char *iname, const char *fname, - int length, void **pobject) +nvkm_falcon_create_(struct nvkm_object *parent, struct nvkm_object *engine, + struct nvkm_oclass *oclass, u32 addr, bool enable, + const char *iname, const char *fname, + int length, void **pobject) { - struct nouveau_falcon *falcon; + struct nvkm_falcon *falcon; int ret; - ret = nouveau_engine_create_(parent, engine, oclass, enable, iname, - fname, length, pobject); + ret = nvkm_engine_create_(parent, engine, oclass, enable, iname, + fname, length, pobject); falcon = *pobject; if (ret) return ret; diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/fifo/base.c b/drivers/gpu/drm/nouveau/nvkm/engine/fifo/base.c index 836c6d3..7e54a52 100644 --- a/drivers/gpu/drm/nouveau/nvkm/engine/fifo/base.c +++ b/drivers/gpu/drm/nouveau/nvkm/engine/fifo/base.c @@ -23,6 +23,8 @@ */ #include +#include +#include #include #include #include diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/gr/nv50.h b/drivers/gpu/drm/nouveau/nvkm/engine/gr/nv50.h index eb39af0..a5cdb43 100644 --- a/drivers/gpu/drm/nouveau/nvkm/engine/gr/nv50.h +++ b/drivers/gpu/drm/nouveau/nvkm/engine/gr/nv50.h @@ -1,7 +1,7 @@ #ifndef __NV50_GR_H__ #define __NV50_GR_H__ +struct nvkm_device; int nv50_grctx_init(struct nouveau_device *, u32 *size); void nv50_grctx_fill(struct nouveau_device *, struct nouveau_gpuobj *); - #endif diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/sw/nv50.h b/drivers/gpu/drm/nouveau/nvkm/engine/sw/nv50.h index 618e41f..fa0a236 100644 --- a/drivers/gpu/drm/nouveau/nvkm/engine/sw/nv50.h +++ b/drivers/gpu/drm/nouveau/nvkm/engine/sw/nv50.h @@ -1,7 +1,7 @@ #ifndef __NVKM_SW_NV50_H__ #define __NVKM_SW_NV50_H__ - #include +#include struct nv50_sw_oclass { struct nouveau_oclass base; diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/vp/nv84.c b/drivers/gpu/drm/nouveau/nvkm/engine/vp/nv84.c index fd6272b..9caa037 100644 --- a/drivers/gpu/drm/nouveau/nvkm/engine/vp/nv84.c +++ b/drivers/gpu/drm/nouveau/nvkm/engine/vp/nv84.c @@ -25,6 +25,8 @@ #include #include +#include + /******************************************************************************* * VP object classes ******************************************************************************/ diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/xtensa.c b/drivers/gpu/drm/nouveau/nvkm/engine/xtensa.c index 9238475..3995d2c 100644 --- a/drivers/gpu/drm/nouveau/nvkm/engine/xtensa.c +++ b/drivers/gpu/drm/nouveau/nvkm/engine/xtensa.c @@ -19,43 +19,42 @@ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ - #include +#include + u32 -_nouveau_xtensa_rd32(struct nouveau_object *object, u64 addr) +_nvkm_xtensa_rd32(struct nvkm_object *object, u64 addr) { - struct nouveau_xtensa *xtensa = (void *)object; + struct nvkm_xtensa *xtensa = (void *)object; return nv_rd32(xtensa, xtensa->addr + addr); } void -_nouveau_xtensa_wr32(struct nouveau_object *object, u64 addr, u32 data) +_nvkm_xtensa_wr32(struct nvkm_object *object, u64 addr, u32 data) { - struct nouveau_xtensa *xtensa = (void *)object; + struct nvkm_xtensa *xtensa = (void *)object; nv_wr32(xtensa, xtensa->addr + addr, data); } int -_nouveau_xtensa_engctx_ctor(struct nouveau_object *parent, - struct nouveau_object *engine, - struct nouveau_oclass *oclass, void *data, u32 size, - struct nouveau_object **pobject) +_nvkm_xtensa_engctx_ctor(struct nvkm_object *parent, struct nvkm_object *engine, + struct nvkm_oclass *oclass, void *data, u32 size, + struct nvkm_object **pobject) { - struct nouveau_engctx *engctx; + struct nvkm_engctx *engctx; int ret; - ret = nouveau_engctx_create(parent, engine, oclass, NULL, - 0x10000, 0x1000, - NVOBJ_FLAG_ZERO_ALLOC, &engctx); + ret = nvkm_engctx_create(parent, engine, oclass, NULL, 0x10000, 0x1000, + NVOBJ_FLAG_ZERO_ALLOC, &engctx); *pobject = nv_object(engctx); return ret; } void -_nouveau_xtensa_intr(struct nouveau_subdev *subdev) +_nvkm_xtensa_intr(struct nvkm_subdev *subdev) { - struct nouveau_xtensa *xtensa = (void *)subdev; + struct nvkm_xtensa *xtensa = (void *)subdev; u32 unk104 = nv_ro32(xtensa, 0xd04); u32 intr = nv_ro32(xtensa, 0xc20); u32 chan = nv_ro32(xtensa, 0xc28); @@ -72,39 +71,36 @@ _nouveau_xtensa_intr(struct nouveau_subdev *subdev) } int -nouveau_xtensa_create_(struct nouveau_object *parent, - struct nouveau_object *engine, - struct nouveau_oclass *oclass, u32 addr, bool enable, - const char *iname, const char *fname, - int length, void **pobject) +nvkm_xtensa_create_(struct nvkm_object *parent, struct nvkm_object *engine, + struct nvkm_oclass *oclass, u32 addr, bool enable, + const char *iname, const char *fname, + int length, void **pobject) { - struct nouveau_xtensa *xtensa; + struct nvkm_xtensa *xtensa; int ret; - ret = nouveau_engine_create_(parent, engine, oclass, enable, iname, - fname, length, pobject); + ret = nvkm_engine_create_(parent, engine, oclass, enable, iname, + fname, length, pobject); xtensa = *pobject; if (ret) return ret; - nv_subdev(xtensa)->intr = _nouveau_xtensa_intr; - + nv_subdev(xtensa)->intr = _nvkm_xtensa_intr; xtensa->addr = addr; - return 0; } int -_nouveau_xtensa_init(struct nouveau_object *object) +_nvkm_xtensa_init(struct nvkm_object *object) { - struct nouveau_device *device = nv_device(object); - struct nouveau_xtensa *xtensa = (void *)object; + struct nvkm_device *device = nv_device(object); + struct nvkm_xtensa *xtensa = (void *)object; const struct firmware *fw; char name[32]; int i, ret; u32 tmp; - ret = nouveau_engine_init(&xtensa->base); + ret = nvkm_engine_init(&xtensa->base); if (ret) return ret; @@ -124,8 +120,8 @@ _nouveau_xtensa_init(struct nouveau_object *object) return -EINVAL; } - ret = nouveau_gpuobj_new(object, NULL, 0x40000, 0x1000, 0, - &xtensa->gpu_fw); + ret = nvkm_gpuobj_new(object, NULL, 0x40000, 0x1000, 0, + &xtensa->gpu_fw); if (ret) { release_firmware(fw); return ret; @@ -157,20 +153,19 @@ _nouveau_xtensa_init(struct nouveau_object *object) nv_wo32(xtensa, 0xc20, 0x3f); /* INTR */ nv_wo32(xtensa, 0xd84, 0x3f); /* INTR_EN */ - return 0; } int -_nouveau_xtensa_fini(struct nouveau_object *object, bool suspend) +_nvkm_xtensa_fini(struct nvkm_object *object, bool suspend) { - struct nouveau_xtensa *xtensa = (void *)object; + struct nvkm_xtensa *xtensa = (void *)object; nv_wo32(xtensa, 0xd84, 0); /* INTR_EN */ nv_wo32(xtensa, 0xd94, 0); /* FIFO_CTRL */ if (!suspend) - nouveau_gpuobj_ref(NULL, &xtensa->gpu_fw); + nvkm_gpuobj_ref(NULL, &xtensa->gpu_fw); - return nouveau_engine_fini(&xtensa->base, suspend); + return nvkm_engine_fini(&xtensa->base, suspend); } diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/gpio/base.c b/drivers/gpu/drm/nouveau/nvkm/subdev/gpio/base.c index 7ad99b7..98d7929 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/gpio/base.c +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/gpio/base.c @@ -22,6 +22,7 @@ * Authors: Ben Skeggs */ +#include #include #include diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/base.c b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/base.c index d1f06e9..bd477cd 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/base.c +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/base.c @@ -22,6 +22,7 @@ * Authors: Ben Skeggs */ +#include #include #include #include -- cgit v0.10.2