drm/nouveau/core: remove the remainder of the previous style (68f3f702) · Commits · e / devices / android_kernel_fairphone_FP5

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

+5 −1

Original line number	Diff line number	Diff line
		@@ -48,7 +48,11 @@ u64 nvif_device_time(struct nvif_device *);

		#define nvxx_device(a) ({ \
		struct nvif_device *_device = (a); \
		nv_device(_device->object.priv); \
		struct { \
		struct nvkm_object object; \
		struct nvkm_device *device; \
		} *_udevice = _device->object.priv; \
		_udevice->device; \
		})
		#define nvxx_bios(a) nvxx_device(a)->bios
		#define nvxx_fb(a) nvxx_device(a)->fb

drivers/gpu/drm/nouveau/include/nvkm/core/device.h

+46 −64

Original line number	Diff line number	Diff line
		#ifndef __NVKM_DEVICE_H__
		#define __NVKM_DEVICE_H__
		#include <core/engine.h>
		#include <core/event.h>
		#include <core/object.h>

		enum nvkm_devidx {
		NVDEV_SUBDEV_VBIOS,

		/* All subdevs from DEVINIT to DEVINIT_LAST will be created before
		* any of them are initialised. This subdev category is used
		* for any subdevs that the VBIOS init table parsing may call out
		* to during POST.
		*/
		NVDEV_SUBDEV_DEVINIT,
		NVDEV_SUBDEV_IBUS,
		NVDEV_SUBDEV_GPIO,
		NVDEV_SUBDEV_I2C,
		NVDEV_SUBDEV_DEVINIT_LAST = NVDEV_SUBDEV_I2C,

		/* This grouping of subdevs are initialised right after they've
		* been created, and are allowed to assume any subdevs in the
		* list above them exist and have been initialised.
		*/
		NVDEV_SUBDEV_FUSE,
		NVDEV_SUBDEV_MXM,
		NVDEV_SUBDEV_MC,
		NVDEV_SUBDEV_BUS,
		NVDEV_SUBDEV_TIMER,
		NVDEV_SUBDEV_FB,
		NVDEV_SUBDEV_LTC,
		NVDEV_SUBDEV_INSTMEM,
		NVDEV_SUBDEV_MMU,
		NVDEV_SUBDEV_BAR,
		NVDEV_SUBDEV_PMU,
		NVDEV_SUBDEV_VOLT,
		NVDEV_SUBDEV_THERM,
		NVDEV_SUBDEV_CLK,

		NVDEV_ENGINE_FIRST,
		NVDEV_ENGINE_DMAOBJ = NVDEV_ENGINE_FIRST,
		NVDEV_ENGINE_IFB,
		NVDEV_ENGINE_FIFO,
		NVDEV_ENGINE_SW,
		NVDEV_ENGINE_GR,
		NVDEV_ENGINE_MPEG,
		NVDEV_ENGINE_ME,
		NVDEV_ENGINE_VP,
		NVDEV_ENGINE_CIPHER,
		NVDEV_ENGINE_BSP,
		NVDEV_ENGINE_MSPPP,
		NVDEV_ENGINE_CE0,
		NVDEV_ENGINE_CE1,
		NVDEV_ENGINE_CE2,
		NVDEV_ENGINE_VIC,
		NVDEV_ENGINE_MSENC,
		NVDEV_ENGINE_DISP,
		NVDEV_ENGINE_PM,
		NVDEV_ENGINE_MSVLD,
		NVDEV_ENGINE_SEC,
		NVDEV_ENGINE_MSPDEC,

		NVDEV_SUBDEV_NR,
		NVKM_SUBDEV_VBIOS,
		NVKM_SUBDEV_DEVINIT,
		NVKM_SUBDEV_IBUS,
		NVKM_SUBDEV_GPIO,
		NVKM_SUBDEV_I2C,
		NVKM_SUBDEV_FUSE,
		NVKM_SUBDEV_MXM,
		NVKM_SUBDEV_MC,
		NVKM_SUBDEV_BUS,
		NVKM_SUBDEV_TIMER,
		NVKM_SUBDEV_FB,
		NVKM_SUBDEV_LTC,
		NVKM_SUBDEV_INSTMEM,
		NVKM_SUBDEV_MMU,
		NVKM_SUBDEV_BAR,
		NVKM_SUBDEV_PMU,
		NVKM_SUBDEV_VOLT,
		NVKM_SUBDEV_THERM,
		NVKM_SUBDEV_CLK,

		NVKM_ENGINE_DMAOBJ,
		NVKM_ENGINE_IFB,
		NVKM_ENGINE_FIFO,
		NVKM_ENGINE_SW,
		NVKM_ENGINE_GR,
		NVKM_ENGINE_MPEG,
		NVKM_ENGINE_ME,
		NVKM_ENGINE_VP,
		NVKM_ENGINE_CIPHER,
		NVKM_ENGINE_BSP,
		NVKM_ENGINE_MSPPP,
		NVKM_ENGINE_CE0,
		NVKM_ENGINE_CE1,
		NVKM_ENGINE_CE2,
		NVKM_ENGINE_VIC,
		NVKM_ENGINE_MSENC,
		NVKM_ENGINE_DISP,
		NVKM_ENGINE_PM,
		NVKM_ENGINE_MSVLD,
		NVKM_ENGINE_SEC,
		NVKM_ENGINE_MSPDEC,

		NVKM_SUBDEV_NR,
		};

		struct nvkm_device {
		struct nvkm_engine engine;

		const struct nvkm_device_func *func;
		const struct nvkm_device_quirk *quirk;
		struct device *dev;
		@@ -85,6 +70,7 @@ struct nvkm_device {
		struct nvkm_event event;

		u64 disable_mask;
		u32 debug;

		const struct nvkm_device_chip *chip;
		enum {
		@@ -103,8 +89,6 @@ struct nvkm_device {
		u8 chiprev;
		u32 crystal;

		struct nvkm_oclass *oclass[NVDEV_SUBDEV_NR];

		struct {
		struct notifier_block nb;
		} acpi;
		@@ -227,8 +211,6 @@ int nvkm_device_list(u64 *name, int size);
		_temp; \
		})

		struct nvkm_device nv_device(void obj);

		static inline bool
		nv_device_match(struct nvkm_device *device, u16 dev, u16 ven, u16 sub)
		{
		@@ -285,7 +267,7 @@ extern const struct nvkm_sclass nvkm_udevice_sclass;
		/* device logging */
		#define nvdev_printk_(d,l,p,f,a...) do { \
		struct nvkm_device *_device = (d); \
		if (_device->engine.subdev.debug >= (l)) \
		if (_device->debug >= (l)) \
		dev_##p(_device->dev, f, ##a); \
		} while(0)
		#define nvdev_printk(d,l,p,f,a...) nvdev_printk_((d), NV_DBG_##l, p, f, ##a)

drivers/gpu/drm/nouveau/include/nvkm/core/engine.h

+3 −49

Original line number	Diff line number	Diff line
		#ifndef __NVKM_ENGINE_H__
		#define __NVKM_ENGINE_H__
		#define nvkm_engine(p) container_of((p), struct nvkm_engine, subdev)
		#include <core/subdev.h>
		struct nvkm_device_oclass; /XXX: DEV!ENG /
		struct nvkm_fifo_chan;
		struct nvkm_fb_tile;

		#define NV_ENGINE_(eng,var) (((var) << 8) \| (eng))
		#define NV_ENGINE(name,var) NV_ENGINE_(NVDEV_ENGINE_##name, (var))

		struct nvkm_engine {
		struct nvkm_subdev subdev;
		const struct nvkm_engine_func *func;
		struct nvkm_subdev subdev;
		spinlock_t lock;

		int usecount;

		struct nvkm_oclass *cclass;
		struct nvkm_oclass *sclass;

		struct list_head contexts;
		spinlock_t lock;
		};

		struct nvkm_engine_func {
		@@ -54,42 +46,4 @@ int nvkm_engine_new_(const struct nvkm_engine_func , struct nvkm_device ,
		struct nvkm_engine nvkm_engine_ref(struct nvkm_engine );
		void nvkm_engine_unref(struct nvkm_engine **);
		void nvkm_engine_tile(struct nvkm_engine *, int region);

		static inline struct nvkm_engine *
		nv_engine(void *obj)
		{
		#if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA
		BUG_ON(!nv_iclass(obj, NV_ENGINE_CLASS));
		#endif
		return obj;
		}

		static inline int
		nv_engidx(struct nvkm_engine *engine)
		{
		return nv_subidx(&engine->subdev);
		}

		struct nvkm_engine nvkm_engine(void obj, int idx);

		#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 nvkm_engine_destroy(p) \
		nvkm_subdev_destroy(&(p)->subdev)
		#define nvkm_engine_init_old(p) \
		nvkm_subdev_init_old(&(p)->subdev)
		#define nvkm_engine_fini_old(p,s) \
		nvkm_subdev_fini_old(&(p)->subdev, (s))

		int nvkm_engine_create_(struct nvkm_object , struct nvkm_object ,
		struct nvkm_oclass , bool, const char ,
		const char , int, void *);

		#define _nvkm_engine_dtor _nvkm_subdev_dtor
		#define _nvkm_engine_init _nvkm_subdev_init
		#define _nvkm_engine_fini _nvkm_subdev_fini

		#include <core/device.h>
		#endif

drivers/gpu/drm/nouveau/include/nvkm/core/gpuobj.h

+2 −35

Original line number	Diff line number	Diff line
		@@ -33,41 +33,8 @@ struct nvkm_gpuobj_func {
		int nvkm_gpuobj_new(struct nvkm_device *, u32 size, int align, bool zero,
		struct nvkm_gpuobj parent, struct nvkm_gpuobj *);
		void nvkm_gpuobj_del(struct nvkm_gpuobj **);

		static inline struct nvkm_gpuobj *
		nv_gpuobj(void *obj)
		{
		#if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA
		BUG_ON(!nv_iclass(obj, NV_GPUOBJ_CLASS));
		#endif
		return obj;
		}

		#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 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 nvkm_gpuobj_destroy(struct nvkm_gpuobj *);

		int nvkm_gpuobj_wrap(struct nvkm_memory , struct nvkm_gpuobj *);
		int nvkm_gpuobj_map(struct nvkm_gpuobj , struct nvkm_vm , u32 access,
		struct nvkm_vma *);
		void nvkm_gpuobj_unmap(struct nvkm_vma *);

		static inline void
		nvkm_gpuobj_ref(struct nvkm_gpuobj obj, struct nvkm_gpuobj *ref)
		{
		nvkm_object_ref(&obj->object, (struct nvkm_object **)ref);
		}

		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

drivers/gpu/drm/nouveau/include/nvkm/core/object.h

+3 −85

Original line number	Diff line number	Diff line
		@@ -4,32 +4,18 @@
		#include <core/debug.h>
		struct nvkm_event;
		struct nvkm_gpuobj;

		#define NV_PARENT_CLASS 0x80000000
		#define NV_NAMEDB_CLASS 0x40000000
		#define NV_CLIENT_CLASS 0x20000000
		#define NV_SUBDEV_CLASS 0x10000000
		#define NV_ENGINE_CLASS 0x08000000
		#define NV_MEMOBJ_CLASS 0x04000000
		#define NV_GPUOBJ_CLASS 0x02000000
		#define NV_ENGCTX_CLASS 0x01000000
		struct nvkm_oclass;

		struct nvkm_object {
		const struct nvkm_object_func *func;
		struct nvkm_client *client;
		struct nvkm_engine *engine;
		u32 oclass_name;
		u32 oclass;
		u32 handle;
		struct nvkm_object *parent;
		struct nvkm_oclass *oclass;
		u32 pclass;
		atomic_t refcount;
		atomic_t usecount;
		#if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA
		#define NVKM_OBJECT_MAGIC 0x75ef0bad
		struct list_head list;
		u32 _magic;
		#endif
		};

		struct nvkm_object_func {
		@@ -71,32 +57,6 @@ int nvkm_object_wr32(struct nvkm_object *, u64 addr, u32 data);
		int nvkm_object_bind(struct nvkm_object , struct nvkm_gpuobj , int align,
		struct nvkm_gpuobj **);

		static inline struct nvkm_object *
		nv_object(void *obj)
		{
		#if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA
		if (likely(obj)) {
		struct nvkm_object *object = obj;
		BUG_ON(object->_magic != NVKM_OBJECT_MAGIC);
		}
		#endif
		return obj;
		}

		#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 _nvkm_object_ctor(struct nvkm_object , struct nvkm_object ,
		struct nvkm_oclass , void , u32,
		struct nvkm_object **);

		extern struct nvkm_ofuncs nvkm_object_ofuncs;

		struct nvkm_sclass {
		int minver;
		int maxver;
		@@ -107,60 +67,18 @@ struct nvkm_sclass {
		};

		struct nvkm_oclass {
		s32 handle;
		struct nvkm_ofuncs * const ofuncs;

		int (ctor)(const struct nvkm_oclass , void *data, u32 size,
		struct nvkm_object **);
		struct nvkm_sclass base;
		const void *priv;
		const void *engn;
		s32 handle;
		u64 object;
		struct nvkm_client *client;
		struct nvkm_object *parent;
		struct nvkm_engine *engine;
		};

		#define nv_oclass(o) nv_object(o)->oclass
		#define nv_hclass(o) nv_oclass(o)->handle
		#define nv_iclass(o,i) (nv_object(o)->pclass & (i))
		#define nv_mclass(o) nv_oclass(o)->handle

		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 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 nvkm_ofuncs *
		nv_ofuncs(void *obj)
		{
		return nv_oclass(obj)->ofuncs;
		}

		int nvkm_object_old(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);