Commit ac35d19f authored by Dave Airlie's avatar Dave Airlie
Browse files

Merge branch '00.00-inst' of git://github.com/skeggsb/linux into drm-next 



Ben wrote:
The problem is that GA100 added enough new engine types and instances
that we would have begun to overflow various u64 bitfields used to
track the connections between various engines.

Rather than addressing subdevs by a unique index, we give
each subdev a type and instance id, and replace the use of bitfields
tied to subdev index with other methods.

Notable changes:
- replace subdev index with subdev type + instance id
- engines that turn out to be fused-off (can't detect until later in
init) no longer leave dangling pointers around
- new subdev/instance additions no longer need to be made in multiple places
- ampere engine topology is now being parsed

Signed-off-by: default avatarDave Airlie <airlied@redhat.com>
From: Ben Skeggs <skeggsb@gmail.com>
Link: https://patchwork.freedesktop.org/patch/msgid/CACAvsv4c_Y923ng0rT1y23wktHHyjEMsusb0=9Z7kQaVbxyPyQ@mail.gmail.com
parents 4c3a3292 f6df392d

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

+24 −28
Original line number Diff line number Diff line
@@ -60,37 +60,33 @@ struct nv_device_time_v0 { 


#define NV_DEVICE_INFO_UNIT                               (0xffffffffULL << 32)

#define NV_DEVICE_INFO(n)                          ((n) | (0x00000000ULL << 32))

#define NV_DEVICE_FIFO(n)                          ((n) | (0x00000001ULL << 32))

#define NV_DEVICE_HOST(n)                          ((n) | (0x00000001ULL << 32))



/* This will be returned for unsupported queries. */

/* This will be returned in the mthd field for unsupported queries. */

#define NV_DEVICE_INFO_INVALID                                           ~0ULL



/* These return a mask of available engines of particular type. */

#define NV_DEVICE_INFO_ENGINE_SW                     NV_DEVICE_INFO(0x00000000)

#define NV_DEVICE_INFO_ENGINE_GR                     NV_DEVICE_INFO(0x00000001)

#define NV_DEVICE_INFO_ENGINE_MPEG                   NV_DEVICE_INFO(0x00000002)

#define NV_DEVICE_INFO_ENGINE_ME                     NV_DEVICE_INFO(0x00000003)

#define NV_DEVICE_INFO_ENGINE_CIPHER                 NV_DEVICE_INFO(0x00000004)

#define NV_DEVICE_INFO_ENGINE_BSP                    NV_DEVICE_INFO(0x00000005)

#define NV_DEVICE_INFO_ENGINE_VP                     NV_DEVICE_INFO(0x00000006)

#define NV_DEVICE_INFO_ENGINE_CE                     NV_DEVICE_INFO(0x00000007)

#define NV_DEVICE_INFO_ENGINE_SEC                    NV_DEVICE_INFO(0x00000008)

#define NV_DEVICE_INFO_ENGINE_MSVLD                  NV_DEVICE_INFO(0x00000009)

#define NV_DEVICE_INFO_ENGINE_MSPDEC                 NV_DEVICE_INFO(0x0000000a)

#define NV_DEVICE_INFO_ENGINE_MSPPP                  NV_DEVICE_INFO(0x0000000b)

#define NV_DEVICE_INFO_ENGINE_MSENC                  NV_DEVICE_INFO(0x0000000c)

#define NV_DEVICE_INFO_ENGINE_VIC                    NV_DEVICE_INFO(0x0000000d)

#define NV_DEVICE_INFO_ENGINE_SEC2                   NV_DEVICE_INFO(0x0000000e)

#define NV_DEVICE_INFO_ENGINE_NVDEC                  NV_DEVICE_INFO(0x0000000f)

#define NV_DEVICE_INFO_ENGINE_NVENC                  NV_DEVICE_INFO(0x00000010)



/* Returns the number of available runlists. */

#define NV_DEVICE_HOST_RUNLISTS                       NV_DEVICE_HOST(0x00000000)

/* Returns the number of available channels. */

#define NV_DEVICE_FIFO_CHANNELS                      NV_DEVICE_FIFO(0x00000000)



/* Returns a mask of available runlists. */

#define NV_DEVICE_FIFO_RUNLISTS                      NV_DEVICE_FIFO(0x00000001)

#define NV_DEVICE_HOST_CHANNELS                       NV_DEVICE_HOST(0x00000001)



/* These return a mask of engines available on a particular runlist. */

#define NV_DEVICE_FIFO_RUNLIST_ENGINES(n)     ((n) + NV_DEVICE_FIFO(0x00000010))

#define NV_DEVICE_FIFO_RUNLIST_ENGINES__SIZE                                64

/* Returns a mask of available engine types on runlist(data). */

#define NV_DEVICE_HOST_RUNLIST_ENGINES                NV_DEVICE_HOST(0x00000100)

#define NV_DEVICE_HOST_RUNLIST_ENGINES_SW                            0x00000001

#define NV_DEVICE_HOST_RUNLIST_ENGINES_GR                            0x00000002

#define NV_DEVICE_HOST_RUNLIST_ENGINES_MPEG                          0x00000004

#define NV_DEVICE_HOST_RUNLIST_ENGINES_ME                            0x00000008

#define NV_DEVICE_HOST_RUNLIST_ENGINES_CIPHER                        0x00000010

#define NV_DEVICE_HOST_RUNLIST_ENGINES_BSP                           0x00000020

#define NV_DEVICE_HOST_RUNLIST_ENGINES_VP                            0x00000040

#define NV_DEVICE_HOST_RUNLIST_ENGINES_CE                            0x00000080

#define NV_DEVICE_HOST_RUNLIST_ENGINES_SEC                           0x00000100

#define NV_DEVICE_HOST_RUNLIST_ENGINES_MSVLD                         0x00000200

#define NV_DEVICE_HOST_RUNLIST_ENGINES_MSPDEC                        0x00000400

#define NV_DEVICE_HOST_RUNLIST_ENGINES_MSPPP                         0x00000800

#define NV_DEVICE_HOST_RUNLIST_ENGINES_MSENC                         0x00001000

#define NV_DEVICE_HOST_RUNLIST_ENGINES_VIC                           0x00002000

#define NV_DEVICE_HOST_RUNLIST_ENGINES_SEC2                          0x00004000

#define NV_DEVICE_HOST_RUNLIST_ENGINES_NVDEC                         0x00008000

#define NV_DEVICE_HOST_RUNLIST_ENGINES_NVENC                         0x00010000

#endif

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

+3 −3
Original line number Diff line number Diff line
@@ -2,15 +2,15 @@ 
#define __NVIF_FIFO_H__

#include <nvif/device.h>



/* Returns mask of runlists that support a NV_DEVICE_INFO_ENGINE_* type. */

/* Returns mask of runlists that support a NV_DEVICE_INFO_RUNLIST_ENGINES_* type. */

u64 nvif_fifo_runlist(struct nvif_device *, u64 engine);



/* CE-supporting runlists (excluding GRCE, if others exist). */

static inline u64

nvif_fifo_runlist_ce(struct nvif_device *device)

{

	u64 runmgr = nvif_fifo_runlist(device, NV_DEVICE_INFO_ENGINE_GR);

	u64 runmce = nvif_fifo_runlist(device, NV_DEVICE_INFO_ENGINE_CE);

	u64 runmgr = nvif_fifo_runlist(device, NV_DEVICE_HOST_RUNLIST_ENGINES_GR);

	u64 runmce = nvif_fifo_runlist(device, NV_DEVICE_HOST_RUNLIST_ENGINES_CE);

	if (runmce && !(runmce &= ~runmgr))

		runmce = runmgr;

	return runmce;

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

+18 −173
Original line number Diff line number Diff line
@@ -3,79 +3,7 @@ 
#define __NVKM_DEVICE_H__

#include <core/oclass.h>

#include <core/event.h>



enum nvkm_devidx {

	NVKM_SUBDEV_PCI,

	NVKM_SUBDEV_VBIOS,

	NVKM_SUBDEV_DEVINIT,

	NVKM_SUBDEV_TOP,

	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_INSTMEM,

	NVKM_SUBDEV_FB,

	NVKM_SUBDEV_LTC,

	NVKM_SUBDEV_MMU,

	NVKM_SUBDEV_BAR,

	NVKM_SUBDEV_FAULT,

	NVKM_SUBDEV_ACR,

	NVKM_SUBDEV_PMU,

	NVKM_SUBDEV_VOLT,

	NVKM_SUBDEV_ICCSENSE,

	NVKM_SUBDEV_THERM,

	NVKM_SUBDEV_CLK,

	NVKM_SUBDEV_GSP,



	NVKM_ENGINE_BSP,



	NVKM_ENGINE_CE0,

	NVKM_ENGINE_CE1,

	NVKM_ENGINE_CE2,

	NVKM_ENGINE_CE3,

	NVKM_ENGINE_CE4,

	NVKM_ENGINE_CE5,

	NVKM_ENGINE_CE6,

	NVKM_ENGINE_CE7,

	NVKM_ENGINE_CE8,

	NVKM_ENGINE_CE_LAST = NVKM_ENGINE_CE8,



	NVKM_ENGINE_CIPHER,

	NVKM_ENGINE_DISP,

	NVKM_ENGINE_DMAOBJ,

	NVKM_ENGINE_FIFO,

	NVKM_ENGINE_GR,

	NVKM_ENGINE_IFB,

	NVKM_ENGINE_ME,

	NVKM_ENGINE_MPEG,

	NVKM_ENGINE_MSENC,

	NVKM_ENGINE_MSPDEC,

	NVKM_ENGINE_MSPPP,

	NVKM_ENGINE_MSVLD,



	NVKM_ENGINE_NVENC0,

	NVKM_ENGINE_NVENC1,

	NVKM_ENGINE_NVENC2,

	NVKM_ENGINE_NVENC_LAST = NVKM_ENGINE_NVENC2,



	NVKM_ENGINE_NVDEC0,

	NVKM_ENGINE_NVDEC1,

	NVKM_ENGINE_NVDEC2,

	NVKM_ENGINE_NVDEC_LAST = NVKM_ENGINE_NVDEC2,



	NVKM_ENGINE_PM,

	NVKM_ENGINE_SEC,

	NVKM_ENGINE_SEC2,

	NVKM_ENGINE_SW,

	NVKM_ENGINE_VIC,

	NVKM_ENGINE_VP,



	NVKM_SUBDEV_NR

};

enum nvkm_subdev_type;



enum nvkm_device_type {

	NVKM_DEVICE_PCI,
@@ -102,7 +30,6 @@ struct nvkm_device { 


	struct nvkm_event event;



	u64 disable_mask;

	u32 debug;



	const struct nvkm_device_chip *chip;
@@ -130,58 +57,16 @@ struct nvkm_device { 
		struct notifier_block nb;

	} acpi;



	struct nvkm_acr *acr;

	struct nvkm_bar *bar;

	struct nvkm_bios *bios;

	struct nvkm_bus *bus;

	struct nvkm_clk *clk;

	struct nvkm_devinit *devinit;

	struct nvkm_fault *fault;

	struct nvkm_fb *fb;

	struct nvkm_fuse *fuse;

	struct nvkm_gpio *gpio;

	struct nvkm_gsp *gsp;

	struct nvkm_i2c *i2c;

	struct nvkm_subdev *ibus;

	struct nvkm_iccsense *iccsense;

	struct nvkm_instmem *imem;

	struct nvkm_ltc *ltc;

	struct nvkm_mc *mc;

	struct nvkm_mmu *mmu;

	struct nvkm_subdev *mxm;

	struct nvkm_pci *pci;

	struct nvkm_pmu *pmu;

	struct nvkm_therm *therm;

	struct nvkm_timer *timer;

	struct nvkm_top *top;

	struct nvkm_volt *volt;



	struct nvkm_engine *bsp;

	struct nvkm_engine *ce[9];

	struct nvkm_engine *cipher;

	struct nvkm_disp *disp;

	struct nvkm_dma *dma;

	struct nvkm_fifo *fifo;

	struct nvkm_gr *gr;

	struct nvkm_engine *ifb;

	struct nvkm_engine *me;

	struct nvkm_engine *mpeg;

	struct nvkm_engine *msenc;

	struct nvkm_engine *mspdec;

	struct nvkm_engine *msppp;

	struct nvkm_engine *msvld;

	struct nvkm_nvenc *nvenc[3];

	struct nvkm_nvdec *nvdec[3];

	struct nvkm_pm *pm;

	struct nvkm_engine *sec;

	struct nvkm_sec2 *sec2;

	struct nvkm_sw *sw;

	struct nvkm_engine *vic;

	struct nvkm_engine *vp;

#define NVKM_LAYOUT_ONCE(type,data,ptr) data *ptr;

#define NVKM_LAYOUT_INST(type,data,ptr,cnt) data *ptr[cnt];

#include <core/layout.h>

#undef NVKM_LAYOUT_INST

#undef NVKM_LAYOUT_ONCE

	struct list_head subdev;

};



struct nvkm_subdev *nvkm_device_subdev(struct nvkm_device *, int index);

struct nvkm_engine *nvkm_device_engine(struct nvkm_device *, int index);

struct nvkm_subdev *nvkm_device_subdev(struct nvkm_device *, int type, int inst);

struct nvkm_engine *nvkm_device_engine(struct nvkm_device *, int type, int inst);



struct nvkm_device_func {

	struct nvkm_device_pci *(*pci)(struct nvkm_device *);
@@ -202,55 +87,15 @@ struct nvkm_device_quirk { 


struct nvkm_device_chip {

	const char *name;



	int (*acr     )(struct nvkm_device *, int idx, struct nvkm_acr **);

	int (*bar     )(struct nvkm_device *, int idx, struct nvkm_bar **);

	int (*bios    )(struct nvkm_device *, int idx, struct nvkm_bios **);

	int (*bus     )(struct nvkm_device *, int idx, struct nvkm_bus **);

	int (*clk     )(struct nvkm_device *, int idx, struct nvkm_clk **);

	int (*devinit )(struct nvkm_device *, int idx, struct nvkm_devinit **);

	int (*fault   )(struct nvkm_device *, int idx, struct nvkm_fault **);

	int (*fb      )(struct nvkm_device *, int idx, struct nvkm_fb **);

	int (*fuse    )(struct nvkm_device *, int idx, struct nvkm_fuse **);

	int (*gpio    )(struct nvkm_device *, int idx, struct nvkm_gpio **);

	int (*gsp     )(struct nvkm_device *, int idx, struct nvkm_gsp **);

	int (*i2c     )(struct nvkm_device *, int idx, struct nvkm_i2c **);

	int (*ibus    )(struct nvkm_device *, int idx, struct nvkm_subdev **);

	int (*iccsense)(struct nvkm_device *, int idx, struct nvkm_iccsense **);

	int (*imem    )(struct nvkm_device *, int idx, struct nvkm_instmem **);

	int (*ltc     )(struct nvkm_device *, int idx, struct nvkm_ltc **);

	int (*mc      )(struct nvkm_device *, int idx, struct nvkm_mc **);

	int (*mmu     )(struct nvkm_device *, int idx, struct nvkm_mmu **);

	int (*mxm     )(struct nvkm_device *, int idx, struct nvkm_subdev **);

	int (*pci     )(struct nvkm_device *, int idx, struct nvkm_pci **);

	int (*pmu     )(struct nvkm_device *, int idx, struct nvkm_pmu **);

	int (*therm   )(struct nvkm_device *, int idx, struct nvkm_therm **);

	int (*timer   )(struct nvkm_device *, int idx, struct nvkm_timer **);

	int (*top     )(struct nvkm_device *, int idx, struct nvkm_top **);

	int (*volt    )(struct nvkm_device *, int idx, struct nvkm_volt **);



	int (*bsp     )(struct nvkm_device *, int idx, struct nvkm_engine **);

	int (*ce[9]   )(struct nvkm_device *, int idx, struct nvkm_engine **);

	int (*cipher  )(struct nvkm_device *, int idx, struct nvkm_engine **);

	int (*disp    )(struct nvkm_device *, int idx, struct nvkm_disp **);

	int (*dma     )(struct nvkm_device *, int idx, struct nvkm_dma **);

	int (*fifo    )(struct nvkm_device *, int idx, struct nvkm_fifo **);

	int (*gr      )(struct nvkm_device *, int idx, struct nvkm_gr **);

	int (*ifb     )(struct nvkm_device *, int idx, struct nvkm_engine **);

	int (*me      )(struct nvkm_device *, int idx, struct nvkm_engine **);

	int (*mpeg    )(struct nvkm_device *, int idx, struct nvkm_engine **);

	int (*msenc   )(struct nvkm_device *, int idx, struct nvkm_engine **);

	int (*mspdec  )(struct nvkm_device *, int idx, struct nvkm_engine **);

	int (*msppp   )(struct nvkm_device *, int idx, struct nvkm_engine **);

	int (*msvld   )(struct nvkm_device *, int idx, struct nvkm_engine **);

	int (*nvenc[3])(struct nvkm_device *, int idx, struct nvkm_nvenc **);

	int (*nvdec[3])(struct nvkm_device *, int idx, struct nvkm_nvdec **);

	int (*pm      )(struct nvkm_device *, int idx, struct nvkm_pm **);

	int (*sec     )(struct nvkm_device *, int idx, struct nvkm_engine **);

	int (*sec2    )(struct nvkm_device *, int idx, struct nvkm_sec2 **);

	int (*sw      )(struct nvkm_device *, int idx, struct nvkm_sw **);

	int (*vic     )(struct nvkm_device *, int idx, struct nvkm_engine **);

	int (*vp      )(struct nvkm_device *, int idx, struct nvkm_engine **);

#define NVKM_LAYOUT_ONCE(type,data,ptr,...)                                                  \

	struct {                                                                             \

		u32 inst;                                                                    \

		int (*ctor)(struct nvkm_device *, enum nvkm_subdev_type, int inst, data **); \

	} ptr;

#define NVKM_LAYOUT_INST(A...) NVKM_LAYOUT_ONCE(A)

#include <core/layout.h>

#undef NVKM_LAYOUT_INST

#undef NVKM_LAYOUT_ONCE

};



struct nvkm_device *nvkm_device_find(u64 name);

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

+10 −3
Original line number Diff line number Diff line
@@ -6,12 +6,18 @@ 
struct nvkm_fifo_chan;

struct nvkm_fb_tile;



extern const struct nvkm_subdev_func nvkm_engine;



struct nvkm_engine {

	const struct nvkm_engine_func *func;

	struct nvkm_subdev subdev;

	spinlock_t lock;



	int usecount;

	struct {

		refcount_t refcount;

		struct mutex mutex;

		bool enabled;

	} use;

};



struct nvkm_engine_func {
@@ -42,9 +48,10 @@ struct nvkm_engine_func { 
};



int nvkm_engine_ctor(const struct nvkm_engine_func *, struct nvkm_device *,

		     int index, bool enable, struct nvkm_engine *);

		     enum nvkm_subdev_type, int inst, bool enable, struct nvkm_engine *);

int nvkm_engine_new_(const struct nvkm_engine_func *, struct nvkm_device *,

		     int index, bool enable, struct nvkm_engine **);

		     enum nvkm_subdev_type, int, bool enable, struct nvkm_engine **);



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);

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

+1 −0
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ struct nvkm_enum { 
	const char *name;

	const void *data;

	u32 data2;

	int inst;

};



const struct nvkm_enum *nvkm_enum_find(const struct nvkm_enum *, u32 value);