UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

drm/nouveau/device: convert ctrl class to new-style nvkm_object 

Signed-off-by: Ben Skeggs <bskeggs@redhat.com>
This commit is contained in:
Ben Skeggs 2015-08-20 14:54:18 +10:00
parent 2a9f847f5d
commit 0e29998a89
5 changed files with 73 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
drivers/gpu/drm/nouveau/include/nvkm/core/device.h
View File

@ -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 */

74
drivers/gpu/drm/nouveau/nvkm/engine/device/ctrl.c
View File

@ -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,
};

12
drivers/gpu/drm/nouveau/nvkm/engine/device/ctrl.h Normal file
View File

@ -0,0 +1,12 @@
#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

2
drivers/gpu/drm/nouveau/nvkm/engine/device/priv.h
View File

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

24
drivers/gpu/drm/nouveau/nvkm/engine/device/user.c
View File

@ -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