Commit efe2a9ec authored by Ben Skeggs's avatar Ben Skeggs
Browse files

drm/nouveau/device: pass instance id when looking up a subdev/engine 



This switches to using the subdev list for lookup, and otherwise should
be a no-op aside from switching the function signatures.

Callers will be transitioned to split type+inst individually.

Signed-off-by: default avatarBen Skeggs <bskeggs@redhat.com>
Reviewed-by: default avatarLyude Paul <lyude@redhat.com>
parent 65a279c1

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

+2 −2
Original line number Original line Diff line number Diff line
@@ -111,8 +111,8 @@ struct nvkm_device { 
	struct list_head subdev;

	struct list_head subdev;

};

};





struct nvkm_subdev *nvkm_device_subdev(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 index);

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





struct nvkm_device_func {

struct nvkm_device_func {

	struct nvkm_device_pci *(*pci)(struct nvkm_device *);

	struct nvkm_device_pci *(*pci)(struct nvkm_device *);

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

+2 −0
Original line number Original line Diff line number Diff line
@@ -6,6 +6,8 @@ 
struct nvkm_fifo_chan;

struct nvkm_fifo_chan;

struct nvkm_fb_tile;

struct nvkm_fb_tile;





extern const struct nvkm_subdev_func nvkm_engine;



struct nvkm_engine {

struct nvkm_engine {

	const struct nvkm_engine_func *func;

	const struct nvkm_engine_func *func;

	struct nvkm_subdev subdev;

	struct nvkm_subdev subdev;

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

+3 −3
Original line number Original line Diff line number Diff line
@@ -165,8 +165,8 @@ nvkm_engine_dtor(struct nvkm_subdev *subdev) 
	return engine;

	return engine;

}

}





static const struct nvkm_subdev_func

const struct nvkm_subdev_func

nvkm_engine_func = {

nvkm_engine = {

	.dtor = nvkm_engine_dtor,

	.dtor = nvkm_engine_dtor,

	.preinit = nvkm_engine_preinit,

	.preinit = nvkm_engine_preinit,

	.init = nvkm_engine_init,

	.init = nvkm_engine_init,
@@ -180,7 +180,7 @@ nvkm_engine_ctor(const struct nvkm_engine_func *func, 
		 struct nvkm_device *device, int index, bool enable,

		 struct nvkm_device *device, int index, bool enable,

		 struct nvkm_engine *engine)

		 struct nvkm_engine *engine)

{

{

	nvkm_subdev_ctor(&nvkm_engine_func, device, index, &engine->subdev);

	nvkm_subdev_ctor(&nvkm_engine, device, index, &engine->subdev);

	engine->func = func;

	engine->func = func;

	refcount_set(&engine->use.refcount, 0);

	refcount_set(&engine->use.refcount, 0);

	mutex_init(&engine->use.mutex);

	mutex_init(&engine->use.mutex);

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

+12 −82
Original line number Original line Diff line number Diff line
@@ -2726,97 +2726,27 @@ nvkm_device_event_func = { 
};

};





struct nvkm_subdev *

struct nvkm_subdev *

nvkm_device_subdev(struct nvkm_device *device, int index)

nvkm_device_subdev(struct nvkm_device *device, int type, int inst)

{

{

	struct nvkm_engine *engine;

	struct nvkm_subdev *subdev;





	if (device->disable_mask & (1ULL << index))

	if (device->disable_mask & (1ULL << (type + inst)))

		return NULL;

		return NULL;





	switch (index) {

	list_for_each_entry(subdev, &device->subdev, head) {

#define _(n,p,m) case NVKM_SUBDEV_##n: if (p) return (m); break

		if (subdev->index == type + inst)

	_(ACR     , device->acr     , &device->acr->subdev);

			return subdev;

	_(BAR     , device->bar     , &device->bar->subdev);

	_(VBIOS   , device->bios    , &device->bios->subdev);

	_(BUS     , device->bus     , &device->bus->subdev);

	_(CLK     , device->clk     , &device->clk->subdev);

	_(DEVINIT , device->devinit , &device->devinit->subdev);

	_(FAULT   , device->fault   , &device->fault->subdev);

	_(FB      , device->fb      , &device->fb->subdev);

	_(FUSE    , device->fuse    , &device->fuse->subdev);

	_(GPIO    , device->gpio    , &device->gpio->subdev);

	_(GSP     , device->gsp     , &device->gsp->subdev);

	_(I2C     , device->i2c     , &device->i2c->subdev);

	_(IBUS    , device->ibus    ,  device->ibus);

	_(ICCSENSE, device->iccsense, &device->iccsense->subdev);

	_(INSTMEM , device->imem    , &device->imem->subdev);

	_(LTC     , device->ltc     , &device->ltc->subdev);

	_(MC      , device->mc      , &device->mc->subdev);

	_(MMU     , device->mmu     , &device->mmu->subdev);

	_(MXM     , device->mxm     ,  device->mxm);

	_(PCI     , device->pci     , &device->pci->subdev);

	_(PMU     , device->pmu     , &device->pmu->subdev);

	_(THERM   , device->therm   , &device->therm->subdev);

	_(TIMER   , device->timer   , &device->timer->subdev);

	_(TOP     , device->top     , &device->top->subdev);

	_(VOLT    , device->volt    , &device->volt->subdev);

#undef _

	default:

		engine = nvkm_device_engine(device, index);

		if (engine)

			return &engine->subdev;

		break;

	}

	}



	return NULL;

	return NULL;

}

}





struct nvkm_engine *

struct nvkm_engine *

nvkm_device_engine(struct nvkm_device *device, int index)

nvkm_device_engine(struct nvkm_device *device, int type, int inst)

{

{

	if (device->disable_mask & (1ULL << index))

	struct nvkm_subdev *subdev = nvkm_device_subdev(device, type, inst);

		return NULL;

	if (subdev && subdev->func == &nvkm_engine)



		return container_of(subdev, struct nvkm_engine, subdev);

	switch (index) {

#define _(n,p,m) case NVKM_ENGINE_##n: if (p) return (m); break

	_(BSP    , device->bsp     ,  device->bsp);

	_(CE0    , device->ce[0]   ,  device->ce[0]);

	_(CE1    , device->ce[1]   ,  device->ce[1]);

	_(CE2    , device->ce[2]   ,  device->ce[2]);

	_(CE3    , device->ce[3]   ,  device->ce[3]);

	_(CE4    , device->ce[4]   ,  device->ce[4]);

	_(CE5    , device->ce[5]   ,  device->ce[5]);

	_(CE6    , device->ce[6]   ,  device->ce[6]);

	_(CE7    , device->ce[7]   ,  device->ce[7]);

	_(CE8    , device->ce[8]   ,  device->ce[8]);

	_(CIPHER , device->cipher  ,  device->cipher);

	_(DISP   , device->disp    , &device->disp->engine);

	_(DMAOBJ , device->dma     , &device->dma->engine);

	_(FIFO   , device->fifo    , &device->fifo->engine);

	_(GR     , device->gr      , &device->gr->engine);

	_(IFB    , device->ifb     ,  device->ifb);

	_(ME     , device->me      ,  device->me);

	_(MPEG   , device->mpeg    ,  device->mpeg);

	_(MSENC  , device->msenc   ,  device->msenc);

	_(MSPDEC , device->mspdec  ,  device->mspdec);

	_(MSPPP  , device->msppp   ,  device->msppp);

	_(MSVLD  , device->msvld   ,  device->msvld);

	_(NVENC0 , device->nvenc[0], &device->nvenc[0]->engine);

	_(NVENC1 , device->nvenc[1], &device->nvenc[1]->engine);

	_(NVENC2 , device->nvenc[2], &device->nvenc[2]->engine);

	_(NVDEC0 , device->nvdec[0], &device->nvdec[0]->engine);

	_(NVDEC1 , device->nvdec[1], &device->nvdec[1]->engine);

	_(NVDEC2 , device->nvdec[2], &device->nvdec[2]->engine);

	_(PM     , device->pm      , &device->pm->engine);

	_(SEC    , device->sec     ,  device->sec);

	_(SEC2   , device->sec2    , &device->sec2->engine);

	_(SW     , device->sw      , &device->sw->engine);

	_(VIC    , device->vic     ,  device->vic);

	_(VP     , device->vp      ,  device->vp);

#undef _

	default:

		WARN_ON(1);

		break;

	}

	return NULL;

	return NULL;

}

}
@@ -3264,7 +3194,7 @@ nvkm_device_ctor(const struct nvkm_device_func *func, 
	if (device->chip->m && (subdev_mask & (1ULL << (s)))) {                \

	if (device->chip->m && (subdev_mask & (1ULL << (s)))) {                \

		ret = device->chip->m(device, (s), &device->m);                \

		ret = device->chip->m(device, (s), &device->m);                \

		if (ret) {                                                     \

		if (ret) {                                                     \

			subdev = nvkm_device_subdev(device, (s));              \

			subdev = nvkm_device_subdev(device, (s), 0);           \

			nvkm_subdev_del(&subdev);                              \

			nvkm_subdev_del(&subdev);                              \

			device->m = NULL;                                      \

			device->m = NULL;                                      \

			if (ret != -ENODEV) {                                  \

			if (ret != -ENODEV) {                                  \

drivers/gpu/drm/nouveau/nvkm/engine/device/user.c

+3 −3
Original line number Original line Diff line number Diff line
@@ -51,7 +51,7 @@ nvkm_udevice_info_subdev(struct nvkm_device *device, u64 mthd, u64 *data) 
		return -EINVAL;

		return -EINVAL;

	}

	}





	subdev = nvkm_device_subdev(device, subidx);

	subdev = nvkm_device_subdev(device, subidx, 0);

	if (subdev)

	if (subdev)

		return nvkm_subdev_info(subdev, mthd, data);

		return nvkm_subdev_info(subdev, mthd, data);

	return -ENODEV;

	return -ENODEV;
@@ -70,7 +70,7 @@ nvkm_udevice_info_v1(struct nvkm_device *device, 
	switch (args->mthd) {

	switch (args->mthd) {

#define ENGINE__(A,B,C) NV_DEVICE_INFO_ENGINE_##A: { int _i;                   \

#define ENGINE__(A,B,C) NV_DEVICE_INFO_ENGINE_##A: { int _i;                   \

	for (_i = (B), args->data = 0ULL; _i <= (C); _i++) {                   \

	for (_i = (B), args->data = 0ULL; _i <= (C); _i++) {                   \

		if (nvkm_device_engine(device, _i))                            \

		if (nvkm_device_engine(device, _i, 0))                         \

			args->data |= BIT_ULL(_i);                             \

			args->data |= BIT_ULL(_i);                             \

	}                                                                      \

	}                                                                      \

}

}
@@ -357,7 +357,7 @@ nvkm_udevice_child_get(struct nvkm_object *object, int index, 
	int i;

	int i;





	for (; i = __ffs64(mask), mask && !sclass; mask &= ~(1ULL << i)) {

	for (; i = __ffs64(mask), mask && !sclass; mask &= ~(1ULL << i)) {

		if (!(engine = nvkm_device_engine(device, i)) ||

		if (!(engine = nvkm_device_engine(device, i, 0)) ||

		    !(engine->func->base.sclass))

		    !(engine->func->base.sclass))

			continue;

			continue;

		oclass->engine = engine;

		oclass->engine = engine;