This source file includes following definitions.
- drm_legacy_ctxbitmap_free
- drm_legacy_ctxbitmap_next
- drm_legacy_ctxbitmap_init
- drm_legacy_ctxbitmap_cleanup
- drm_legacy_ctxbitmap_flush
- drm_legacy_getsareactx
- drm_legacy_setsareactx
- drm_context_switch
- drm_context_switch_complete
- drm_legacy_resctx
- drm_legacy_addctx
- drm_legacy_getctx
- drm_legacy_switchctx
- drm_legacy_newctx
- drm_legacy_rmctx
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
26
27
28
29
30
31 #include <linux/slab.h>
32 #include <linux/uaccess.h>
33
34 #include <drm/drm_drv.h>
35 #include <drm/drm_file.h>
36 #include <drm/drm_print.h>
37
38 #include "drm_legacy.h"
39
40 struct drm_ctx_list {
41 struct list_head head;
42 drm_context_t handle;
43 struct drm_file *tag;
44 };
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60 void drm_legacy_ctxbitmap_free(struct drm_device * dev, int ctx_handle)
61 {
62 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
63 !drm_core_check_feature(dev, DRIVER_LEGACY))
64 return;
65
66 mutex_lock(&dev->struct_mutex);
67 idr_remove(&dev->ctx_idr, ctx_handle);
68 mutex_unlock(&dev->struct_mutex);
69 }
70
71
72
73
74
75
76
77
78
79
80 static int drm_legacy_ctxbitmap_next(struct drm_device * dev)
81 {
82 int ret;
83
84 mutex_lock(&dev->struct_mutex);
85 ret = idr_alloc(&dev->ctx_idr, NULL, DRM_RESERVED_CONTEXTS, 0,
86 GFP_KERNEL);
87 mutex_unlock(&dev->struct_mutex);
88 return ret;
89 }
90
91
92
93
94
95
96
97
98 void drm_legacy_ctxbitmap_init(struct drm_device * dev)
99 {
100 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
101 !drm_core_check_feature(dev, DRIVER_LEGACY))
102 return;
103
104 idr_init(&dev->ctx_idr);
105 }
106
107
108
109
110
111
112
113
114
115 void drm_legacy_ctxbitmap_cleanup(struct drm_device * dev)
116 {
117 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
118 !drm_core_check_feature(dev, DRIVER_LEGACY))
119 return;
120
121 mutex_lock(&dev->struct_mutex);
122 idr_destroy(&dev->ctx_idr);
123 mutex_unlock(&dev->struct_mutex);
124 }
125
126
127
128
129
130
131
132
133
134
135 void drm_legacy_ctxbitmap_flush(struct drm_device *dev, struct drm_file *file)
136 {
137 struct drm_ctx_list *pos, *tmp;
138
139 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
140 !drm_core_check_feature(dev, DRIVER_LEGACY))
141 return;
142
143 mutex_lock(&dev->ctxlist_mutex);
144
145 list_for_each_entry_safe(pos, tmp, &dev->ctxlist, head) {
146 if (pos->tag == file &&
147 pos->handle != DRM_KERNEL_CONTEXT) {
148 if (dev->driver->context_dtor)
149 dev->driver->context_dtor(dev, pos->handle);
150
151 drm_legacy_ctxbitmap_free(dev, pos->handle);
152 list_del(&pos->head);
153 kfree(pos);
154 }
155 }
156
157 mutex_unlock(&dev->ctxlist_mutex);
158 }
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178 int drm_legacy_getsareactx(struct drm_device *dev, void *data,
179 struct drm_file *file_priv)
180 {
181 struct drm_ctx_priv_map *request = data;
182 struct drm_local_map *map;
183 struct drm_map_list *_entry;
184
185 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
186 !drm_core_check_feature(dev, DRIVER_LEGACY))
187 return -EOPNOTSUPP;
188
189 mutex_lock(&dev->struct_mutex);
190
191 map = idr_find(&dev->ctx_idr, request->ctx_id);
192 if (!map) {
193 mutex_unlock(&dev->struct_mutex);
194 return -EINVAL;
195 }
196
197 request->handle = NULL;
198 list_for_each_entry(_entry, &dev->maplist, head) {
199 if (_entry->map == map) {
200 request->handle =
201 (void *)(unsigned long)_entry->user_token;
202 break;
203 }
204 }
205
206 mutex_unlock(&dev->struct_mutex);
207
208 if (request->handle == NULL)
209 return -EINVAL;
210
211 return 0;
212 }
213
214
215
216
217
218
219
220
221
222
223
224
225
226 int drm_legacy_setsareactx(struct drm_device *dev, void *data,
227 struct drm_file *file_priv)
228 {
229 struct drm_ctx_priv_map *request = data;
230 struct drm_local_map *map = NULL;
231 struct drm_map_list *r_list = NULL;
232
233 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
234 !drm_core_check_feature(dev, DRIVER_LEGACY))
235 return -EOPNOTSUPP;
236
237 mutex_lock(&dev->struct_mutex);
238 list_for_each_entry(r_list, &dev->maplist, head) {
239 if (r_list->map
240 && r_list->user_token == (unsigned long) request->handle)
241 goto found;
242 }
243 bad:
244 mutex_unlock(&dev->struct_mutex);
245 return -EINVAL;
246
247 found:
248 map = r_list->map;
249 if (!map)
250 goto bad;
251
252 if (IS_ERR(idr_replace(&dev->ctx_idr, map, request->ctx_id)))
253 goto bad;
254
255 mutex_unlock(&dev->struct_mutex);
256
257 return 0;
258 }
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276 static int drm_context_switch(struct drm_device * dev, int old, int new)
277 {
278 if (test_and_set_bit(0, &dev->context_flag)) {
279 DRM_ERROR("Reentering -- FIXME\n");
280 return -EBUSY;
281 }
282
283 DRM_DEBUG("Context switch from %d to %d\n", old, new);
284
285 if (new == dev->last_context) {
286 clear_bit(0, &dev->context_flag);
287 return 0;
288 }
289
290 return 0;
291 }
292
293
294
295
296
297
298
299
300
301
302
303
304 static int drm_context_switch_complete(struct drm_device *dev,
305 struct drm_file *file_priv, int new)
306 {
307 dev->last_context = new;
308
309 if (!_DRM_LOCK_IS_HELD(file_priv->master->lock.hw_lock->lock)) {
310 DRM_ERROR("Lock isn't held after context switch\n");
311 }
312
313
314
315
316 clear_bit(0, &dev->context_flag);
317
318 return 0;
319 }
320
321
322
323
324
325
326
327
328
329
330 int drm_legacy_resctx(struct drm_device *dev, void *data,
331 struct drm_file *file_priv)
332 {
333 struct drm_ctx_res *res = data;
334 struct drm_ctx ctx;
335 int i;
336
337 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
338 !drm_core_check_feature(dev, DRIVER_LEGACY))
339 return -EOPNOTSUPP;
340
341 if (res->count >= DRM_RESERVED_CONTEXTS) {
342 memset(&ctx, 0, sizeof(ctx));
343 for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
344 ctx.handle = i;
345 if (copy_to_user(&res->contexts[i], &ctx, sizeof(ctx)))
346 return -EFAULT;
347 }
348 }
349 res->count = DRM_RESERVED_CONTEXTS;
350
351 return 0;
352 }
353
354
355
356
357
358
359
360
361
362
363
364
365 int drm_legacy_addctx(struct drm_device *dev, void *data,
366 struct drm_file *file_priv)
367 {
368 struct drm_ctx_list *ctx_entry;
369 struct drm_ctx *ctx = data;
370 int tmp_handle;
371
372 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
373 !drm_core_check_feature(dev, DRIVER_LEGACY))
374 return -EOPNOTSUPP;
375
376 tmp_handle = drm_legacy_ctxbitmap_next(dev);
377 if (tmp_handle == DRM_KERNEL_CONTEXT) {
378
379 tmp_handle = drm_legacy_ctxbitmap_next(dev);
380 }
381 DRM_DEBUG("%d\n", tmp_handle);
382 if (tmp_handle < 0) {
383 DRM_DEBUG("Not enough free contexts.\n");
384
385 return tmp_handle;
386 }
387
388 ctx->handle = tmp_handle;
389
390 ctx_entry = kmalloc(sizeof(*ctx_entry), GFP_KERNEL);
391 if (!ctx_entry) {
392 DRM_DEBUG("out of memory\n");
393 return -ENOMEM;
394 }
395
396 INIT_LIST_HEAD(&ctx_entry->head);
397 ctx_entry->handle = ctx->handle;
398 ctx_entry->tag = file_priv;
399
400 mutex_lock(&dev->ctxlist_mutex);
401 list_add(&ctx_entry->head, &dev->ctxlist);
402 mutex_unlock(&dev->ctxlist_mutex);
403
404 return 0;
405 }
406
407
408
409
410
411
412
413
414
415
416 int drm_legacy_getctx(struct drm_device *dev, void *data,
417 struct drm_file *file_priv)
418 {
419 struct drm_ctx *ctx = data;
420
421 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
422 !drm_core_check_feature(dev, DRIVER_LEGACY))
423 return -EOPNOTSUPP;
424
425
426 ctx->flags = 0;
427
428 return 0;
429 }
430
431
432
433
434
435
436
437
438
439
440
441
442 int drm_legacy_switchctx(struct drm_device *dev, void *data,
443 struct drm_file *file_priv)
444 {
445 struct drm_ctx *ctx = data;
446
447 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
448 !drm_core_check_feature(dev, DRIVER_LEGACY))
449 return -EOPNOTSUPP;
450
451 DRM_DEBUG("%d\n", ctx->handle);
452 return drm_context_switch(dev, dev->last_context, ctx->handle);
453 }
454
455
456
457
458
459
460
461
462
463
464
465
466 int drm_legacy_newctx(struct drm_device *dev, void *data,
467 struct drm_file *file_priv)
468 {
469 struct drm_ctx *ctx = data;
470
471 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
472 !drm_core_check_feature(dev, DRIVER_LEGACY))
473 return -EOPNOTSUPP;
474
475 DRM_DEBUG("%d\n", ctx->handle);
476 drm_context_switch_complete(dev, file_priv, ctx->handle);
477
478 return 0;
479 }
480
481
482
483
484
485
486
487
488
489
490
491
492 int drm_legacy_rmctx(struct drm_device *dev, void *data,
493 struct drm_file *file_priv)
494 {
495 struct drm_ctx *ctx = data;
496
497 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
498 !drm_core_check_feature(dev, DRIVER_LEGACY))
499 return -EOPNOTSUPP;
500
501 DRM_DEBUG("%d\n", ctx->handle);
502 if (ctx->handle != DRM_KERNEL_CONTEXT) {
503 if (dev->driver->context_dtor)
504 dev->driver->context_dtor(dev, ctx->handle);
505 drm_legacy_ctxbitmap_free(dev, ctx->handle);
506 }
507
508 mutex_lock(&dev->ctxlist_mutex);
509 if (!list_empty(&dev->ctxlist)) {
510 struct drm_ctx_list *pos, *n;
511
512 list_for_each_entry_safe(pos, n, &dev->ctxlist, head) {
513 if (pos->handle == ctx->handle) {
514 list_del(&pos->head);
515 kfree(pos);
516 }
517 }
518 }
519 mutex_unlock(&dev->ctxlist_mutex);
520
521 return 0;
522 }
523
524