drm/nouveau/device: convert ctrl class to new-style nvkm_object (0e29998a) · Commits · 戴 / test

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

+6 −0

Original line number	Diff line number	Diff line
		@@ -274,6 +274,12 @@ enum nv_bus_type {

		void nvkm_device_del(struct nvkm_device **);

		struct nvkm_device_oclass {
		int (ctor)(struct nvkm_device , const struct nvkm_oclass *,
		void data, u32 size, struct nvkm_object *);
		struct nvkm_sclass base;
		};

		extern const struct nvkm_sclass nvkm_udevice_sclass;

		/* device logging */

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

+43 −31

Original line number	Diff line number	Diff line
		@@ -21,7 +21,7 @@
		*
		* Authors: Ben Skeggs <bskeggs@redhat.com>
		*/
		#include "priv.h"
		#include "ctrl.h"

		#include <core/client.h>
		#include <subdev/clk.h>
		@@ -31,17 +31,17 @@
		#include <nvif/unpack.h>

		static int
		nvkm_control_mthd_pstate_info(struct nvkm_object object, void data, u32 size)
		nvkm_control_mthd_pstate_info(struct nvkm_control ctrl, void data, u32 size)
		{
		union {
		struct nvif_control_pstate_info_v0 v0;
		} *args = data;
		struct nvkm_clk *clk = nvkm_clk(object);
		struct nvkm_clk *clk = ctrl->device->clk;
		int ret;

		nvif_ioctl(object, "control pstate info size %d\n", size);
		nvif_ioctl(&ctrl->object, "control pstate info size %d\n", size);
		if (nvif_unpack(args->v0, 0, 0, false)) {
		nvif_ioctl(object, "control pstate info vers %d\n",
		nvif_ioctl(&ctrl->object, "control pstate info vers %d\n",
		args->v0.version);
		} else
		return ret;
		@@ -64,12 +64,12 @@ nvkm_control_mthd_pstate_info(struct nvkm_object object, void data, u32 size)
		}

		static int
		nvkm_control_mthd_pstate_attr(struct nvkm_object object, void data, u32 size)
		nvkm_control_mthd_pstate_attr(struct nvkm_control ctrl, void data, u32 size)
		{
		union {
		struct nvif_control_pstate_attr_v0 v0;
		} *args = data;
		struct nvkm_clk *clk = nvkm_clk(object);
		struct nvkm_clk *clk = ctrl->device->clk;
		struct nvkm_domain *domain;
		struct nvkm_pstate *pstate;
		struct nvkm_cstate *cstate;
		@@ -77,10 +77,10 @@ nvkm_control_mthd_pstate_attr(struct nvkm_object object, void data, u32 size)
		u32 lo, hi;
		int ret;

		nvif_ioctl(object, "control pstate attr size %d\n", size);
		nvif_ioctl(&ctrl->object, "control pstate attr size %d\n", size);
		if (nvif_unpack(args->v0, 0, 0, false)) {
		nvif_ioctl(object, "control pstate attr vers %d state %d "
		"index %d\n",
		nvif_ioctl(&ctrl->object,
		"control pstate attr vers %d state %d index %d\n",
		args->v0.version, args->v0.state, args->v0.index);
		if (!clk)
		return -ENODEV;
		@@ -137,19 +137,19 @@ nvkm_control_mthd_pstate_attr(struct nvkm_object object, void data, u32 size)
		}

		static int
		nvkm_control_mthd_pstate_user(struct nvkm_object object, void data, u32 size)
		nvkm_control_mthd_pstate_user(struct nvkm_control ctrl, void data, u32 size)
		{
		union {
		struct nvif_control_pstate_user_v0 v0;
		} *args = data;
		struct nvkm_clk *clk = nvkm_clk(object);
		struct nvkm_clk *clk = ctrl->device->clk;
		int ret;

		nvif_ioctl(object, "control pstate user size %d\n", size);
		nvif_ioctl(&ctrl->object, "control pstate user size %d\n", size);
		if (nvif_unpack(args->v0, 0, 0, false)) {
		nvif_ioctl(object, "control pstate user vers %d ustate %d "
		"pwrsrc %d\n", args->v0.version,
		args->v0.ustate, args->v0.pwrsrc);
		nvif_ioctl(&ctrl->object,
		"control pstate user vers %d ustate %d pwrsrc %d\n",
		args->v0.version, args->v0.ustate, args->v0.pwrsrc);
		if (!clk)
		return -ENODEV;
		} else
		@@ -168,32 +168,44 @@ nvkm_control_mthd_pstate_user(struct nvkm_object object, void data, u32 size)
		static int
		nvkm_control_mthd(struct nvkm_object object, u32 mthd, void data, u32 size)
		{
		struct nvkm_control *ctrl = nvkm_control(object);
		switch (mthd) {
		case NVIF_CONTROL_PSTATE_INFO:
		return nvkm_control_mthd_pstate_info(object, data, size);
		return nvkm_control_mthd_pstate_info(ctrl, data, size);
		case NVIF_CONTROL_PSTATE_ATTR:
		return nvkm_control_mthd_pstate_attr(object, data, size);
		return nvkm_control_mthd_pstate_attr(ctrl, data, size);
		case NVIF_CONTROL_PSTATE_USER:
		return nvkm_control_mthd_pstate_user(object, data, size);
		return nvkm_control_mthd_pstate_user(ctrl, data, size);
		default:
		break;
		}
		return -EINVAL;
		}

		static struct nvkm_ofuncs
		nvkm_control_ofuncs = {
		.ctor = _nvkm_object_ctor,
		.dtor = nvkm_object_destroy,
		.init = _nvkm_object_init,
		.fini = _nvkm_object_fini,
		static const struct nvkm_object_func
		nvkm_control = {
		.mthd = nvkm_control_mthd,
		};

		struct nvkm_oclass
		nvkm_control_oclass[] = {
		{ .handle = NVIF_IOCTL_NEW_V0_CONTROL,
		.ofuncs = &nvkm_control_ofuncs
		},
		{}
		static int
		nvkm_control_new(struct nvkm_device device, const struct nvkm_oclass oclass,
		void data, u32 size, struct nvkm_object *pobject)
		{
		struct nvkm_control *ctrl;

		if (!(ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL)))
		return -ENOMEM;
		*pobject = &ctrl->object;
		ctrl->device = device;

		nvkm_object_ctor(&nvkm_control, oclass, &ctrl->object);
		return 0;
		}

		const struct nvkm_device_oclass
		nvkm_control_oclass = {
		.base.oclass = NVIF_IOCTL_NEW_V0_CONTROL,
		.base.minver = -1,
		.base.maxver = -1,
		.ctor = nvkm_control_new,
		};

drivers/gpu/drm/nouveau/nvkm/engine/device/ctrl.h

0 → 100644

+12 −0

Original line number	Diff line number	Diff line
		#ifndef __NVKM_DEVICE_CTRL_H__
		#define __NVKM_DEVICE_CTRL_H__
		#define nvkm_control(p) container_of((p), struct nvkm_control, object)
		#include <core/device.h>

		struct nvkm_control {
		struct nvkm_object object;
		struct nvkm_device *device;
		};

		extern const struct nvkm_device_oclass nvkm_control_oclass;
		#endif

drivers/gpu/drm/nouveau/nvkm/engine/device/priv.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -47,8 +47,6 @@ int nvkm_device_ctor(const struct nvkm_device_func *,
		int nvkm_device_init(struct nvkm_device *);
		int nvkm_device_fini(struct nvkm_device *, bool suspend);

		extern struct nvkm_oclass nvkm_control_oclass[];

		int nv04_identify(struct nvkm_device *);
		int nv10_identify(struct nvkm_device *);
		int nv20_identify(struct nvkm_device *);

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

+12 −12

Original line number	Diff line number	Diff line
		@@ -23,6 +23,7 @@
		*/
		#define nvkm_udevice(p) container_of((p), struct nvkm_udevice, object)
		#include "priv.h"
		#include "ctrl.h"

		#include <core/client.h>
		#include <core/parent.h>
		@@ -280,10 +281,8 @@ nvkm_udevice_child_new(const struct nvkm_oclass *oclass,
		void data, u32 size, struct nvkm_object *pobject)
		{
		struct nvkm_udevice *udev = nvkm_udevice(oclass->parent);
		const struct nvkm_oclass *sclass = oclass->priv;
		return nvkm_object_old(&udev->object, NULL,
		(struct nvkm_oclass *)sclass,
		data, size, pobject);
		const struct nvkm_device_oclass *sclass = oclass->priv;
		return sclass->ctor(udev->device, oclass, data, size, pobject);
		}

		static int
		@@ -297,6 +296,7 @@ nvkm_udevice_child_get(struct nvkm_object *object, int index,
		(1ULL << NVDEV_ENGINE_FIFO) \|
		(1ULL << NVDEV_ENGINE_DISP) \|
		(1ULL << NVDEV_ENGINE_PM);
		const struct nvkm_device_oclass *sclass;
		int i;

		for (; i = __ffs64(mask), mask; mask &= ~(1ULL << i)) {
		@@ -319,16 +319,16 @@ nvkm_udevice_child_get(struct nvkm_object *object, int index,
		}
		}

		if (index == 0) {
		oclass->ctor = nvkm_udevice_child_new;
		oclass->base.oclass = nvkm_control_oclass[0].handle;
		oclass->base.minver = -2;
		oclass->base.maxver = -2;
		oclass->priv = &nvkm_control_oclass[0];
		return 0;
		switch (index) {
		case 0: sclass = &nvkm_control_oclass; break;
		default:
		return -EINVAL;
		}

		return -EINVAL;
		oclass->ctor = nvkm_udevice_child_new;
		oclass->base = sclass->base;
		oclass->priv = sclass;
		return 0;
		}

		static const struct nvkm_object_func

Admin message