1 /*
2 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
3 * Use is subject to license terms.
4 */
5
6 /*
7 * drm_context.h -- IOCTLs for generic contexts -*- linux-c -*-
8 * Created: Fri Nov 24 18:31:37 2000 by gareth@valinux.com
9 */
10 /*
11 * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.
12 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
13 * All Rights Reserved.
14 *
15 * Permission is hereby granted, free of charge, to any person obtaining a
16 * copy of this software and associated documentation files (the "Software"),
17 * to deal in the Software without restriction, including without limitation
18 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
19 * and/or sell copies of the Software, and to permit persons to whom the
20 * Software is furnished to do so, subject to the following conditions:
21 *
22 * The above copyright notice and this permission notice (including the next
23 * paragraph) shall be included in all copies or substantial portions of the
24 * Software.
25 *
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
27 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
28 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
29 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
30 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
31 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
32 * OTHER DEALINGS IN THE SOFTWARE.
33 *
34 * Authors:
35 * Rickard E. (Rik) Faith <faith@valinux.com>
36 * Gareth Hughes <gareth@valinux.com>
37 *
38 */
39
40 #pragma ident "%Z%%M% %I% %E% SMI"
41
42 #include "drmP.h"
43 #include "drm_io32.h"
44
45 static inline int
46 find_first_zero_bit(volatile void *p, int max)
47 {
48 int b;
49 volatile int *ptr = (volatile int *)p;
50
51 for (b = 0; b < max; b += 32) {
52 if (ptr[b >> 5] != ~0) {
53 for (;;) {
54 if ((ptr[b >> 5] & (1 << (b & 0x1f))) == 0)
55 return (b);
56 b++;
57 }
58 }
59 }
60 return (max);
61 }
62
63 /*
64 * Context bitmap support
65 */
66 void
67 drm_ctxbitmap_free(drm_device_t *dev, int ctx_handle)
68 {
69 if (ctx_handle < 0 || ctx_handle >= DRM_MAX_CTXBITMAP ||
70 dev->ctx_bitmap == NULL) {
71 DRM_ERROR("drm_ctxbitmap_free: Attempt to free\
72 invalid context handle: %d\n",
73 ctx_handle);
74 return;
75 }
76
77 DRM_LOCK();
78 clear_bit(ctx_handle, dev->ctx_bitmap);
79 dev->context_sareas[ctx_handle] = NULL;
80 DRM_UNLOCK();
81 }
82
83 /* Is supposed to return -1 if any error by calling functions */
84 int
85 drm_ctxbitmap_next(drm_device_t *dev)
86 {
87 int bit;
88
89 if (dev->ctx_bitmap == NULL)
90 return (-1);
91
92 DRM_LOCK();
93 bit = find_first_zero_bit(dev->ctx_bitmap, DRM_MAX_CTXBITMAP);
94 if (bit >= DRM_MAX_CTXBITMAP) {
95 DRM_UNLOCK();
96 return (-1);
97 }
98
99 set_bit(bit, dev->ctx_bitmap);
100 DRM_DEBUG("drm_ctxbitmap_next: bit : %d", bit);
101 if ((bit+1) > dev->max_context) {
102 dev->max_context = (bit+1);
103 if (dev->context_sareas != NULL) {
104 drm_local_map_t **ctx_sareas;
105 ctx_sareas = drm_realloc(dev->context_sareas,
106 (dev->max_context - 1) *
107 sizeof (*dev->context_sareas),
108 dev->max_context *
109 sizeof (*dev->context_sareas),
110 DRM_MEM_MAPS);
111 if (ctx_sareas == NULL) {
112 clear_bit(bit, dev->ctx_bitmap);
113 DRM_UNLOCK();
114 return (-1);
115 }
116 dev->context_sareas = ctx_sareas;
117 dev->context_sareas[bit] = NULL;
118 } else {
119 /* max_context == 1 at this point */
120 dev->context_sareas = drm_alloc(dev->max_context *
121 sizeof (*dev->context_sareas), KM_NOSLEEP);
122 if (dev->context_sareas == NULL) {
123 clear_bit(bit, dev->ctx_bitmap);
124 DRM_UNLOCK();
125 return (-1);
126 }
127 dev->context_sareas[bit] = NULL;
128 }
129 }
130 DRM_UNLOCK();
131 DRM_DEBUG("drm_ctxbitmap_next: return %d", bit);
132 return (bit);
133 }
134
135 int
136 drm_ctxbitmap_init(drm_device_t *dev)
137 {
138 int i;
139 int temp;
140
141 DRM_LOCK();
142 dev->ctx_bitmap = drm_calloc(1, DRM_PAGE_SIZE, DRM_MEM_CTXBITMAP);
143 if (dev->ctx_bitmap == NULL) {
144 DRM_UNLOCK();
145 return (ENOMEM);
146 }
147 dev->context_sareas = NULL;
148 dev->max_context = -1;
149 DRM_UNLOCK();
150
151 for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
152 temp = drm_ctxbitmap_next(dev);
153 DRM_DEBUG("drm_ctxbitmap_init : %d", temp);
154 }
155 return (0);
156 }
157
158 void
159 drm_ctxbitmap_cleanup(drm_device_t *dev)
160 {
161 DRM_LOCK();
162 if (dev->context_sareas != NULL)
163 drm_free(dev->context_sareas,
164 sizeof (*dev->context_sareas) *
165 dev->max_context,
166 DRM_MEM_MAPS);
167 drm_free(dev->ctx_bitmap, DRM_PAGE_SIZE, DRM_MEM_CTXBITMAP);
168 DRM_UNLOCK();
169 }
170
171 /*
172 * Per Context SAREA Support
173 */
174 /*ARGSUSED*/
175 int
176 drm_getsareactx(DRM_IOCTL_ARGS)
177 {
178 DRM_DEVICE;
179 drm_ctx_priv_map_t request;
180 drm_local_map_t *map;
181
182 #ifdef _MULTI_DATAMODEL
183 if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
184 drm_ctx_priv_map_32_t request32;
185 DRM_COPYFROM_WITH_RETURN(&request32, (void *)data,
186 sizeof (drm_ctx_priv_map_32_t));
187 request.ctx_id = request32.ctx_id;
188 request.handle = (void *)(uintptr_t)request32.handle;
189 } else
190 #endif
191 DRM_COPYFROM_WITH_RETURN(&request, (void *)data,
192 sizeof (request));
193
194 DRM_LOCK();
195 if (dev->max_context < 0 || request.ctx_id >= (unsigned)
196 dev->max_context) {
197 DRM_UNLOCK();
198 return (EINVAL);
199 }
200
201 map = dev->context_sareas[request.ctx_id];
202 DRM_UNLOCK();
203
204 if (!map)
205 return (EINVAL);
206
207 request.handle = map->handle;
208
209 #ifdef _MULTI_DATAMODEL
210 if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
211 drm_ctx_priv_map_32_t request32;
212 request32.ctx_id = request.ctx_id;
213 request32.handle = (caddr32_t)(uintptr_t)request.handle;
214 DRM_COPYTO_WITH_RETURN((void *)data, &request32,
215 sizeof (drm_ctx_priv_map_32_t));
216 } else
217 #endif
218 DRM_COPYTO_WITH_RETURN((void *)data,
219 &request, sizeof (request));
220
221 return (0);
222 }
223
224 /*ARGSUSED*/
225 int
226 drm_setsareactx(DRM_IOCTL_ARGS)
227 {
228 DRM_DEVICE;
229 drm_ctx_priv_map_t request;
230 drm_local_map_t *map = NULL;
231
232 #ifdef _MULTI_DATAMODEL
233 if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
234 drm_ctx_priv_map_32_t request32;
235
236 DRM_COPYFROM_WITH_RETURN(&request32, (void *)data,
237 sizeof (drm_ctx_priv_map_32_t));
238 request.ctx_id = request32.ctx_id;
239 request.handle = (void *)(uintptr_t)request32.handle;
240 } else
241 #endif
242 DRM_COPYFROM_WITH_RETURN(&request,
243 (void *)data, sizeof (request));
244
245 DRM_LOCK();
246 TAILQ_FOREACH(map, &dev->maplist, link) {
247 if (map->handle == request.handle) {
248 if (dev->max_context < 0)
249 goto bad;
250 if (request.ctx_id >= (unsigned)dev->max_context)
251 goto bad;
252 dev->context_sareas[request.ctx_id] = map;
253 DRM_UNLOCK();
254 return (0);
255 }
256 }
257
258 bad:
259 DRM_UNLOCK();
260 return (EINVAL);
261 }
262
263 /*
264 * The actual DRM context handling routines
265 */
266 int
267 drm_context_switch(drm_device_t *dev, int old, int new)
268 {
269 if (test_and_set_bit(0, &dev->context_flag)) {
270 DRM_ERROR("drm_context_switch: Reentering -- FIXME");
271 return (EBUSY);
272 }
273
274 DRM_DEBUG("drm_context_switch: Context switch from %d to %d",
275 old, new);
276
277 if (new == dev->last_context) {
278 clear_bit(0, &dev->context_flag);
279 return (0);
280 }
281
282 return (0);
283 }
284
285 int
286 drm_context_switch_complete(drm_device_t *dev, int new)
287 {
288 dev->last_context = new; /* PRE/POST: This is the _only_ writer. */
289
290 if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
291 DRM_ERROR(
292 "drm_context_switch_complete: Lock not held");
293 }
294 /*
295 * If a context switch is ever initiated
296 * when the kernel holds the lock, release
297 * that lock here.
298 */
299 clear_bit(0, &dev->context_flag);
300
301 return (0);
302 }
303
304 /*ARGSUSED*/
305 int
306 drm_resctx(DRM_IOCTL_ARGS)
307 {
308 drm_ctx_res_t res;
309 drm_ctx_t ctx;
310 int i;
311
312 #ifdef _MULTI_DATAMODEL
313 if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
314 drm_ctx_res_32_t res32;
315 DRM_COPYFROM_WITH_RETURN(&res32, (void *)data, sizeof (res32));
316 res.count = res32.count;
317 res.contexts = (drm_ctx_t *)(uintptr_t)res32.contexts;
318 } else
319 #endif
320 DRM_COPYFROM_WITH_RETURN(&res, (void *)data, sizeof (res));
321
322 if (res.count >= DRM_RESERVED_CONTEXTS) {
323 bzero(&ctx, sizeof (ctx));
324 for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
325 ctx.handle = i;
326 DRM_COPYTO_WITH_RETURN(&res.contexts[i],
327 &ctx, sizeof (ctx));
328 }
329 }
330 res.count = DRM_RESERVED_CONTEXTS;
331
332 #ifdef _MULTI_DATAMODEL
333 if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
334 drm_ctx_res_32_t res32;
335 res32.count = res.count;
336 res32.contexts = (caddr32_t)(uintptr_t)res.contexts;
337
338 DRM_COPYTO_WITH_RETURN((void *)data, &res32,
339 sizeof (drm_ctx_res_32_t));
340 } else
341 #endif
342 DRM_COPYTO_WITH_RETURN((void *)data, &res, sizeof (res));
343
344 return (0);
345 }
346
347 /*ARGSUSED*/
348 int
349 drm_addctx(DRM_IOCTL_ARGS)
350 {
351 DRM_DEVICE;
352 drm_ctx_t ctx;
353
354 DRM_COPYFROM_WITH_RETURN(&ctx, (void *)data, sizeof (ctx));
355
356 ctx.handle = drm_ctxbitmap_next(dev);
357 if (ctx.handle == DRM_KERNEL_CONTEXT) {
358 /* Skip kernel's context and get a new one. */
359 ctx.handle = drm_ctxbitmap_next(dev);
360 }
361 if (ctx.handle == (drm_context_t)-1) {
362 return (ENOMEM);
363 }
364
365 if (dev->driver->context_ctor && ctx.handle != DRM_KERNEL_CONTEXT) {
366 dev->driver->context_ctor(dev, ctx.handle);
367 }
368
369 DRM_COPYTO_WITH_RETURN((void *)data, &ctx, sizeof (ctx));
370
371 return (0);
372 }
373
374 /*ARGSUSED*/
375 int
376 drm_modctx(DRM_IOCTL_ARGS)
377 {
378 /* This does nothing */
379 return (0);
380 }
381
382 /*ARGSUSED*/
383 int
384 drm_getctx(DRM_IOCTL_ARGS)
385 {
386 drm_ctx_t ctx;
387
388 DRM_COPYFROM_WITH_RETURN(&ctx, (void *)data, sizeof (ctx));
389
390 /* This is 0, because we don't handle any context flags */
391 ctx.flags = 0;
392
393 DRM_COPYTO_WITH_RETURN((void *)data, &ctx, sizeof (ctx));
394
395 return (0);
396 }
397
398 /*ARGSUSED*/
399 int
400 drm_switchctx(DRM_IOCTL_ARGS)
401 {
402 DRM_DEVICE;
403 drm_ctx_t ctx;
404
405 DRM_COPYFROM_WITH_RETURN(&ctx, (void *)data, sizeof (ctx));
406
407 DRM_DEBUG("drm_switchctx: %d", ctx.handle);
408 return (drm_context_switch(dev, dev->last_context, ctx.handle));
409 }
410
411 /*ARGSUSED*/
412 int
413 drm_newctx(DRM_IOCTL_ARGS)
414 {
415 DRM_DEVICE;
416 drm_ctx_t ctx;
417
418 DRM_COPYFROM_WITH_RETURN(&ctx, (void *)data, sizeof (ctx));
419
420 DRM_DEBUG("drm_newctx: %d", ctx.handle);
421 (void) drm_context_switch_complete(dev, ctx.handle);
422
423 return (0);
424 }
425
426 /*ARGSUSED*/
427 int
428 drm_rmctx(DRM_IOCTL_ARGS)
429 {
430 DRM_DEVICE;
431 drm_ctx_t ctx;
432
433 DRM_COPYFROM_WITH_RETURN(&ctx, (void *)data, sizeof (ctx));
434
435 DRM_DEBUG("drm_rmctx : %d", ctx.handle);
436 if (ctx.handle != DRM_KERNEL_CONTEXT) {
437 if (dev->driver->context_dtor) {
438 DRM_LOCK();
439 dev->driver->context_dtor(dev, ctx.handle);
440 DRM_UNLOCK();
441 }
442
443 drm_ctxbitmap_free(dev, ctx.handle);
444 }
445
446 return (0);
447 }