1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include <core/object.h>
26#include <core/namedb.h>
27#include <core/handle.h>
28#include <core/client.h>
29#include <core/engctx.h>
30
31#include <subdev/vm.h>
32
33static inline int
34nouveau_engctx_exists(struct nouveau_object *parent,
35 struct nouveau_engine *engine, void **pobject)
36{
37 struct nouveau_engctx *engctx;
38 struct nouveau_object *parctx;
39
40 list_for_each_entry(engctx, &engine->contexts, head) {
41 parctx = nv_pclass(nv_object(engctx), NV_PARENT_CLASS);
42 if (parctx == parent) {
43 atomic_inc(&nv_object(engctx)->refcount);
44 *pobject = engctx;
45 return 1;
46 }
47 }
48
49 return 0;
50}
51
52int
53nouveau_engctx_create_(struct nouveau_object *parent,
54 struct nouveau_object *engobj,
55 struct nouveau_oclass *oclass,
56 struct nouveau_object *pargpu,
57 u32 size, u32 align, u32 flags,
58 int length, void **pobject)
59{
60 struct nouveau_client *client = nouveau_client(parent);
61 struct nouveau_engine *engine = nv_engine(engobj);
62 struct nouveau_object *engctx;
63 unsigned long save;
64 int ret;
65
66
67
68
69 spin_lock_irqsave(&engine->lock, save);
70 ret = nouveau_engctx_exists(parent, engine, pobject);
71 spin_unlock_irqrestore(&engine->lock, save);
72 if (ret)
73 return ret;
74
75
76
77
78 if (size) {
79 ret = nouveau_gpuobj_create_(parent, engobj, oclass,
80 NV_ENGCTX_CLASS,
81 pargpu, size, align, flags,
82 length, pobject);
83 } else {
84 ret = nouveau_object_create_(parent, engobj, oclass,
85 NV_ENGCTX_CLASS, length, pobject);
86 }
87
88 engctx = *pobject;
89 if (ret)
90 return ret;
91
92
93
94
95
96 spin_lock_irqsave(&engine->lock, save);
97 ret = nouveau_engctx_exists(parent, engine, pobject);
98 if (ret) {
99 spin_unlock_irqrestore(&engine->lock, save);
100 nouveau_object_ref(NULL, &engctx);
101 return ret;
102 }
103
104 if (client->vm)
105 atomic_inc(&client->vm->engref[nv_engidx(engobj)]);
106 list_add(&nv_engctx(engctx)->head, &engine->contexts);
107 nv_engctx(engctx)->addr = ~0ULL;
108 spin_unlock_irqrestore(&engine->lock, save);
109 return 0;
110}
111
112void
113nouveau_engctx_destroy(struct nouveau_engctx *engctx)
114{
115 struct nouveau_object *engobj = nv_object(engctx)->engine;
116 struct nouveau_engine *engine = nv_engine(engobj);
117 struct nouveau_client *client = nouveau_client(engctx);
118 unsigned long save;
119
120 nouveau_gpuobj_unmap(&engctx->vma);
121 spin_lock_irqsave(&engine->lock, save);
122 list_del(&engctx->head);
123 spin_unlock_irqrestore(&engine->lock, save);
124
125 if (client->vm)
126 atomic_dec(&client->vm->engref[nv_engidx(engobj)]);
127
128 if (engctx->base.size)
129 nouveau_gpuobj_destroy(&engctx->base);
130 else
131 nouveau_object_destroy(&engctx->base.base);
132}
133
134int
135nouveau_engctx_init(struct nouveau_engctx *engctx)
136{
137 struct nouveau_object *object = nv_object(engctx);
138 struct nouveau_subdev *subdev = nv_subdev(object->engine);
139 struct nouveau_object *parent;
140 struct nouveau_subdev *pardev;
141 int ret;
142
143 ret = nouveau_gpuobj_init(&engctx->base);
144 if (ret)
145 return ret;
146
147 parent = nv_pclass(object->parent, NV_PARENT_CLASS);
148 pardev = nv_subdev(parent->engine);
149 if (nv_parent(parent)->context_attach) {
150 mutex_lock(&pardev->mutex);
151 ret = nv_parent(parent)->context_attach(parent, object);
152 mutex_unlock(&pardev->mutex);
153 }
154
155 if (ret) {
156 nv_error(parent, "failed to attach %s context, %d\n",
157 subdev->name, ret);
158 return ret;
159 }
160
161 nv_debug(parent, "attached %s context\n", subdev->name);
162 return 0;
163}
164
165int
166nouveau_engctx_fini(struct nouveau_engctx *engctx, bool suspend)
167{
168 struct nouveau_object *object = nv_object(engctx);
169 struct nouveau_subdev *subdev = nv_subdev(object->engine);
170 struct nouveau_object *parent;
171 struct nouveau_subdev *pardev;
172 int ret = 0;
173
174 parent = nv_pclass(object->parent, NV_PARENT_CLASS);
175 pardev = nv_subdev(parent->engine);
176 if (nv_parent(parent)->context_detach) {
177 mutex_lock(&pardev->mutex);
178 ret = nv_parent(parent)->context_detach(parent, suspend, object);
179 mutex_unlock(&pardev->mutex);
180 }
181
182 if (ret) {
183 nv_error(parent, "failed to detach %s context, %d\n",
184 subdev->name, ret);
185 return ret;
186 }
187
188 nv_debug(parent, "detached %s context\n", subdev->name);
189 return nouveau_gpuobj_fini(&engctx->base, suspend);
190}
191
192int
193_nouveau_engctx_ctor(struct nouveau_object *parent,
194 struct nouveau_object *engine,
195 struct nouveau_oclass *oclass, void *data, u32 size,
196 struct nouveau_object **pobject)
197{
198 struct nouveau_engctx *engctx;
199 int ret;
200
201 ret = nouveau_engctx_create(parent, engine, oclass, NULL, 256, 256,
202 NVOBJ_FLAG_ZERO_ALLOC, &engctx);
203 *pobject = nv_object(engctx);
204 return ret;
205}
206
207void
208_nouveau_engctx_dtor(struct nouveau_object *object)
209{
210 nouveau_engctx_destroy(nv_engctx(object));
211}
212
213int
214_nouveau_engctx_init(struct nouveau_object *object)
215{
216 return nouveau_engctx_init(nv_engctx(object));
217}
218
219
220int
221_nouveau_engctx_fini(struct nouveau_object *object, bool suspend)
222{
223 return nouveau_engctx_fini(nv_engctx(object), suspend);
224}
225
226struct nouveau_object *
227nouveau_engctx_get(struct nouveau_engine *engine, u64 addr)
228{
229 struct nouveau_engctx *engctx;
230 unsigned long flags;
231
232 spin_lock_irqsave(&engine->lock, flags);
233 list_for_each_entry(engctx, &engine->contexts, head) {
234 if (engctx->addr == addr) {
235 engctx->save = flags;
236 return nv_object(engctx);
237 }
238 }
239 spin_unlock_irqrestore(&engine->lock, flags);
240 return NULL;
241}
242
243void
244nouveau_engctx_put(struct nouveau_object *object)
245{
246 if (object) {
247 struct nouveau_engine *engine = nv_engine(object->engine);
248 struct nouveau_engctx *engctx = nv_engctx(object);
249 spin_unlock_irqrestore(&engine->lock, engctx->save);
250 }
251}
252