nvkm/core/oproxy.c

0001 /*
0002  * Copyright 2015 Red Hat Inc.
0003  *
0004  * Permission is hereby granted, free of charge, to any person obtaining a
0005  * copy of this software and associated documentation files (the "Software"),
0006  * to deal in the Software without restriction, including without limitation
0007  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
0008  * and/or sell copies of the Software, and to permit persons to whom the
0009  * Software is furnished to do so, subject to the following conditions:
0010  *
0011  * The above copyright notice and this permission notice shall be included in
0012  * all copies or substantial portions of the Software.
0013  *
0014  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
0015  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
0016  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
0017  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
0018  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
0019  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
0020  * OTHER DEALINGS IN THE SOFTWARE.
0021  *
0022  * Authors: Ben Skeggs <bskeggs@redhat.com>
0023  */
0024 #include <core/oproxy.h>
0025
0026 static int
0027 nvkm_oproxy_mthd(struct nvkm_object *object, u32 mthd, void *data, u32 size)
0028 {
0029     return nvkm_object_mthd(nvkm_oproxy(object)->object, mthd, data, size);
0030 }
0031
0032 static int
0033 nvkm_oproxy_ntfy(struct nvkm_object *object, u32 mthd,
0034          struct nvkm_event **pevent)
0035 {
0036     return nvkm_object_ntfy(nvkm_oproxy(object)->object, mthd, pevent);
0037 }
0038
0039 static int
0040 nvkm_oproxy_map(struct nvkm_object *object, void *argv, u32 argc,
0041         enum nvkm_object_map *type, u64 *addr, u64 *size)
0042 {
0043     struct nvkm_oproxy *oproxy = nvkm_oproxy(object);
0044     return nvkm_object_map(oproxy->object, argv, argc, type, addr, size);
0045 }
0046
0047 static int
0048 nvkm_oproxy_unmap(struct nvkm_object *object)
0049 {
0050     return nvkm_object_unmap(nvkm_oproxy(object)->object);
0051 }
0052
0053 static int
0054 nvkm_oproxy_rd08(struct nvkm_object *object, u64 addr, u8 *data)
0055 {
0056     return nvkm_object_rd08(nvkm_oproxy(object)->object, addr, data);
0057 }
0058
0059 static int
0060 nvkm_oproxy_rd16(struct nvkm_object *object, u64 addr, u16 *data)
0061 {
0062     return nvkm_object_rd16(nvkm_oproxy(object)->object, addr, data);
0063 }
0064
0065 static int
0066 nvkm_oproxy_rd32(struct nvkm_object *object, u64 addr, u32 *data)
0067 {
0068     return nvkm_object_rd32(nvkm_oproxy(object)->object, addr, data);
0069 }
0070
0071 static int
0072 nvkm_oproxy_wr08(struct nvkm_object *object, u64 addr, u8 data)
0073 {
0074     return nvkm_object_wr08(nvkm_oproxy(object)->object, addr, data);
0075 }
0076
0077 static int
0078 nvkm_oproxy_wr16(struct nvkm_object *object, u64 addr, u16 data)
0079 {
0080     return nvkm_object_wr16(nvkm_oproxy(object)->object, addr, data);
0081 }
0082
0083 static int
0084 nvkm_oproxy_wr32(struct nvkm_object *object, u64 addr, u32 data)
0085 {
0086     return nvkm_object_wr32(nvkm_oproxy(object)->object, addr, data);
0087 }
0088
0089 static int
0090 nvkm_oproxy_bind(struct nvkm_object *object, struct nvkm_gpuobj *parent,
0091          int align, struct nvkm_gpuobj **pgpuobj)
0092 {
0093     return nvkm_object_bind(nvkm_oproxy(object)->object,
0094                 parent, align, pgpuobj);
0095 }
0096
0097 static int
0098 nvkm_oproxy_sclass(struct nvkm_object *object, int index,
0099            struct nvkm_oclass *oclass)
0100 {
0101     struct nvkm_oproxy *oproxy = nvkm_oproxy(object);
0102     oclass->parent = oproxy->object;
0103     if (!oproxy->object->func->sclass)
0104         return -ENODEV;
0105     return oproxy->object->func->sclass(oproxy->object, index, oclass);
0106 }
0107
0108 static int
0109 nvkm_oproxy_fini(struct nvkm_object *object, bool suspend)
0110 {
0111     struct nvkm_oproxy *oproxy = nvkm_oproxy(object);
0112     int ret;
0113
0114     if (oproxy->func->fini[0]) {
0115         ret = oproxy->func->fini[0](oproxy, suspend);
0116         if (ret && suspend)
0117             return ret;
0118     }
0119
0120     if (oproxy->object->func->fini) {
0121         ret = oproxy->object->func->fini(oproxy->object, suspend);
0122         if (ret && suspend)
0123             return ret;
0124     }
0125
0126     if (oproxy->func->fini[1]) {
0127         ret = oproxy->func->fini[1](oproxy, suspend);
0128         if (ret && suspend)
0129             return ret;
0130     }
0131
0132     return 0;
0133 }
0134
0135 static int
0136 nvkm_oproxy_init(struct nvkm_object *object)
0137 {
0138     struct nvkm_oproxy *oproxy = nvkm_oproxy(object);
0139     int ret;
0140
0141     if (oproxy->func->init[0]) {
0142         ret = oproxy->func->init[0](oproxy);
0143         if (ret)
0144             return ret;
0145     }
0146
0147     if (oproxy->object->func->init) {
0148         ret = oproxy->object->func->init(oproxy->object);
0149         if (ret)
0150             return ret;
0151     }
0152
0153     if (oproxy->func->init[1]) {
0154         ret = oproxy->func->init[1](oproxy);
0155         if (ret)
0156             return ret;
0157     }
0158
0159     return 0;
0160 }
0161
0162 static void *
0163 nvkm_oproxy_dtor(struct nvkm_object *object)
0164 {
0165     struct nvkm_oproxy *oproxy = nvkm_oproxy(object);
0166     if (oproxy->func->dtor[0])
0167         oproxy->func->dtor[0](oproxy);
0168     nvkm_object_del(&oproxy->object);
0169     if (oproxy->func->dtor[1])
0170         oproxy->func->dtor[1](oproxy);
0171     return oproxy;
0172 }
0173
0174 static const struct nvkm_object_func
0175 nvkm_oproxy_func = {
0176     .dtor = nvkm_oproxy_dtor,
0177     .init = nvkm_oproxy_init,
0178     .fini = nvkm_oproxy_fini,
0179     .mthd = nvkm_oproxy_mthd,
0180     .ntfy = nvkm_oproxy_ntfy,
0181     .map = nvkm_oproxy_map,
0182     .unmap = nvkm_oproxy_unmap,
0183     .rd08 = nvkm_oproxy_rd08,
0184     .rd16 = nvkm_oproxy_rd16,
0185     .rd32 = nvkm_oproxy_rd32,
0186     .wr08 = nvkm_oproxy_wr08,
0187     .wr16 = nvkm_oproxy_wr16,
0188     .wr32 = nvkm_oproxy_wr32,
0189     .bind = nvkm_oproxy_bind,
0190     .sclass = nvkm_oproxy_sclass,
0191 };
0192
0193 void
0194 nvkm_oproxy_ctor(const struct nvkm_oproxy_func *func,
0195          const struct nvkm_oclass *oclass, struct nvkm_oproxy *oproxy)
0196 {
0197     nvkm_object_ctor(&nvkm_oproxy_func, oclass, &oproxy->base);
0198     oproxy->func = func;
0199 }
0200
0201 int
0202 nvkm_oproxy_new_(const struct nvkm_oproxy_func *func,
0203          const struct nvkm_oclass *oclass, struct nvkm_oproxy **poproxy)
0204 {
0205     if (!(*poproxy = kzalloc(sizeof(**poproxy), GFP_KERNEL)))
0206         return -ENOMEM;
0207     nvkm_oproxy_ctor(func, oclass, *poproxy);
0208     return 0;
0209 }