1 /** 2 * \file drm_context.c 3 * IOCTLs for generic contexts 4 * 5 * \author Rickard E. (Rik) Faith <faith@valinux.com> 6 * \author Gareth Hughes <gareth@valinux.com> 7 */ 8 9 /* 10 * Created: Fri Nov 24 18:31:37 2000 by gareth@valinux.com 11 * 12 * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas. 13 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. 14 * All Rights Reserved. 15 * 16 * Permission is hereby granted, free of charge, to any person obtaining a 17 * copy of this software and associated documentation files (the "Software"), 18 * to deal in the Software without restriction, including without limitation 19 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 20 * and/or sell copies of the Software, and to permit persons to whom the 21 * Software is furnished to do so, subject to the following conditions: 22 * 23 * The above copyright notice and this permission notice (including the next 24 * paragraph) shall be included in all copies or substantial portions of the 25 * Software. 26 * 27 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 28 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 29 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 30 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 31 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 32 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 33 * OTHER DEALINGS IN THE SOFTWARE. 34 */ 35 36 #include <sys/cdefs.h> 37 __FBSDID("$FreeBSD$"); 38 39 /* 40 * ChangeLog: 41 * 2001-11-16 Torsten Duwe <duwe@caldera.de> 42 * added context constructor/destructor hooks, 43 * needed by SiS driver's memory management. 44 */ 45 46 #include <dev/drm2/drmP.h> 47 48 /******************************************************************/ 49 /** \name Context bitmap support */ 50 /*@{*/ 51 52 /** 53 * Free a handle from the context bitmap. 54 * 55 * \param dev DRM device. 56 * \param ctx_handle context handle. 57 * 58 * Clears the bit specified by \p ctx_handle in drm_device::ctx_bitmap and the entry 59 * in drm_device::ctx_idr, while holding the drm_device::struct_mutex 60 * lock. 61 */ 62 void drm_ctxbitmap_free(struct drm_device * dev, int ctx_handle) 63 { 64 if (ctx_handle < 0 || ctx_handle >= DRM_MAX_CTXBITMAP || 65 dev->ctx_bitmap == NULL) { 66 DRM_ERROR("Attempt to free invalid context handle: %d\n", 67 ctx_handle); 68 return; 69 } 70 71 DRM_LOCK(dev); 72 clear_bit(ctx_handle, dev->ctx_bitmap); 73 dev->context_sareas[ctx_handle] = NULL; 74 DRM_UNLOCK(dev); 75 } 76 77 /** 78 * Context bitmap allocation. 79 * 80 * \param dev DRM device. 81 * \return (non-negative) context handle on success or a negative number on failure. 82 * 83 * Allocate a new idr from drm_device::ctx_idr while holding the 84 * drm_device::struct_mutex lock. 85 */ 86 static int drm_ctxbitmap_next(struct drm_device * dev) 87 { 88 int bit; 89 90 if (dev->ctx_bitmap == NULL) 91 return -1; 92 93 DRM_LOCK(dev); 94 bit = find_first_zero_bit(dev->ctx_bitmap, DRM_MAX_CTXBITMAP); 95 if (bit >= DRM_MAX_CTXBITMAP) { 96 DRM_UNLOCK(dev); 97 return -1; 98 } 99 100 set_bit(bit, dev->ctx_bitmap); 101 DRM_DEBUG("bit : %d\n", bit); 102 if ((bit+1) > dev->max_context) { 103 struct drm_local_map **ctx_sareas; 104 int max_ctx = (bit+1); 105 106 ctx_sareas = realloc(dev->context_sareas, 107 max_ctx * sizeof(*dev->context_sareas), 108 DRM_MEM_SAREA, M_NOWAIT); 109 if (ctx_sareas == NULL) { 110 clear_bit(bit, dev->ctx_bitmap); 111 DRM_DEBUG("failed to allocate bit : %d\n", bit); 112 DRM_UNLOCK(dev); 113 return -1; 114 } 115 dev->max_context = max_ctx; 116 dev->context_sareas = ctx_sareas; 117 dev->context_sareas[bit] = NULL; 118 } 119 DRM_UNLOCK(dev); 120 return bit; 121 } 122 123 /** 124 * Context bitmap initialization. 125 * 126 * \param dev DRM device. 127 * 128 * Initialise the drm_device::ctx_idr 129 */ 130 int drm_ctxbitmap_init(struct drm_device * dev) 131 { 132 int i; 133 int temp; 134 135 DRM_LOCK(dev); 136 dev->ctx_bitmap = malloc(PAGE_SIZE, DRM_MEM_CTXBITMAP, 137 M_NOWAIT | M_ZERO); 138 if (dev->ctx_bitmap == NULL) { 139 DRM_UNLOCK(dev); 140 return ENOMEM; 141 } 142 dev->context_sareas = NULL; 143 dev->max_context = -1; 144 DRM_UNLOCK(dev); 145 146 for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) { 147 temp = drm_ctxbitmap_next(dev); 148 DRM_DEBUG("drm_ctxbitmap_init : %d\n", temp); 149 } 150 151 return 0; 152 } 153 154 /** 155 * Context bitmap cleanup. 156 * 157 * \param dev DRM device. 158 * 159 * Free all idr members using drm_ctx_sarea_free helper function 160 * while holding the drm_device::struct_mutex lock. 161 */ 162 void drm_ctxbitmap_cleanup(struct drm_device * dev) 163 { 164 DRM_LOCK(dev); 165 if (dev->context_sareas != NULL) 166 free(dev->context_sareas, DRM_MEM_SAREA); 167 free(dev->ctx_bitmap, DRM_MEM_CTXBITMAP); 168 DRM_UNLOCK(dev); 169 } 170 171 /*@}*/ 172 173 /******************************************************************/ 174 /** \name Per Context SAREA Support */ 175 /*@{*/ 176 177 /** 178 * Get per-context SAREA. 179 * 180 * \param inode device inode. 181 * \param file_priv DRM file private. 182 * \param cmd command. 183 * \param arg user argument pointing to a drm_ctx_priv_map structure. 184 * \return zero on success or a negative number on failure. 185 * 186 * Gets the map from drm_device::ctx_idr with the handle specified and 187 * returns its handle. 188 */ 189 int drm_getsareactx(struct drm_device *dev, void *data, 190 struct drm_file *file_priv) 191 { 192 struct drm_ctx_priv_map *request = data; 193 struct drm_local_map *map; 194 195 DRM_LOCK(dev); 196 if (dev->max_context < 0 || 197 request->ctx_id >= (unsigned) dev->max_context) { 198 DRM_UNLOCK(dev); 199 return EINVAL; 200 } 201 202 map = dev->context_sareas[request->ctx_id]; 203 DRM_UNLOCK(dev); 204 205 request->handle = (void *)map->handle; 206 207 return 0; 208 } 209 210 /** 211 * Set per-context SAREA. 212 * 213 * \param inode device inode. 214 * \param file_priv DRM file private. 215 * \param cmd command. 216 * \param arg user argument pointing to a drm_ctx_priv_map structure. 217 * \return zero on success or a negative number on failure. 218 * 219 * Searches the mapping specified in \p arg and update the entry in 220 * drm_device::ctx_idr with it. 221 */ 222 int drm_setsareactx(struct drm_device *dev, void *data, 223 struct drm_file *file_priv) 224 { 225 struct drm_ctx_priv_map *request = data; 226 struct drm_local_map *map = NULL; 227 struct drm_map_list *r_list = NULL; 228 229 DRM_LOCK(dev); 230 list_for_each_entry(r_list, &dev->maplist, head) { 231 if (r_list->map 232 && r_list->user_token == (unsigned long) request->handle) { 233 if (dev->max_context < 0) 234 goto bad; 235 if (request->ctx_id >= (unsigned) dev->max_context) 236 goto bad; 237 dev->context_sareas[request->ctx_id] = map; 238 DRM_UNLOCK(dev); 239 return 0; 240 } 241 } 242 243 bad: 244 DRM_UNLOCK(dev); 245 return EINVAL; 246 } 247 248 /*@}*/ 249 250 /******************************************************************/ 251 /** \name The actual DRM context handling routines */ 252 /*@{*/ 253 254 /** 255 * Switch context. 256 * 257 * \param dev DRM device. 258 * \param old old context handle. 259 * \param new new context handle. 260 * \return zero on success or a negative number on failure. 261 * 262 * Attempt to set drm_device::context_flag. 263 */ 264 static int drm_context_switch(struct drm_device * dev, int old, int new) 265 { 266 if (test_and_set_bit(0, &dev->context_flag)) { 267 DRM_ERROR("Reentering -- FIXME\n"); 268 return -EBUSY; 269 } 270 271 DRM_DEBUG("Context switch from %d to %d\n", old, new); 272 273 if (new == dev->last_context) { 274 clear_bit(0, &dev->context_flag); 275 return 0; 276 } 277 278 return 0; 279 } 280 281 /** 282 * Complete context switch. 283 * 284 * \param dev DRM device. 285 * \param new new context handle. 286 * \return zero on success or a negative number on failure. 287 * 288 * Updates drm_device::last_context and drm_device::last_switch. Verifies the 289 * hardware lock is held, clears the drm_device::context_flag and wakes up 290 * drm_device::context_wait. 291 */ 292 static int drm_context_switch_complete(struct drm_device *dev, 293 struct drm_file *file_priv, int new) 294 { 295 dev->last_context = new; /* PRE/POST: This is the _only_ writer. */ 296 dev->last_switch = jiffies; 297 298 if (!_DRM_LOCK_IS_HELD(file_priv->master->lock.hw_lock->lock)) { 299 DRM_ERROR("Lock isn't held after context switch\n"); 300 } 301 302 /* If a context switch is ever initiated 303 when the kernel holds the lock, release 304 that lock here. */ 305 clear_bit(0, &dev->context_flag); 306 wakeup(&dev->context_wait); 307 308 return 0; 309 } 310 311 /** 312 * Reserve contexts. 313 * 314 * \param inode device inode. 315 * \param file_priv DRM file private. 316 * \param cmd command. 317 * \param arg user argument pointing to a drm_ctx_res structure. 318 * \return zero on success or a negative number on failure. 319 */ 320 int drm_resctx(struct drm_device *dev, void *data, 321 struct drm_file *file_priv) 322 { 323 struct drm_ctx_res *res = data; 324 struct drm_ctx ctx; 325 int i; 326 327 if (res->count >= DRM_RESERVED_CONTEXTS) { 328 memset(&ctx, 0, sizeof(ctx)); 329 for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) { 330 ctx.handle = i; 331 if (copy_to_user(&res->contexts[i], &ctx, sizeof(ctx))) 332 return -EFAULT; 333 } 334 } 335 res->count = DRM_RESERVED_CONTEXTS; 336 337 return 0; 338 } 339 340 /** 341 * Add context. 342 * 343 * \param inode device inode. 344 * \param file_priv DRM file private. 345 * \param cmd command. 346 * \param arg user argument pointing to a drm_ctx structure. 347 * \return zero on success or a negative number on failure. 348 * 349 * Get a new handle for the context and copy to userspace. 350 */ 351 int drm_addctx(struct drm_device *dev, void *data, 352 struct drm_file *file_priv) 353 { 354 struct drm_ctx_list *ctx_entry; 355 struct drm_ctx *ctx = data; 356 357 ctx->handle = drm_ctxbitmap_next(dev); 358 if (ctx->handle == DRM_KERNEL_CONTEXT) { 359 /* Skip kernel's context and get a new one. */ 360 ctx->handle = drm_ctxbitmap_next(dev); 361 } 362 DRM_DEBUG("%d\n", ctx->handle); 363 if (ctx->handle == -1) { 364 DRM_DEBUG("Not enough free contexts.\n"); 365 /* Should this return -EBUSY instead? */ 366 return -ENOMEM; 367 } 368 369 ctx_entry = malloc(sizeof(*ctx_entry), DRM_MEM_CTXBITMAP, M_NOWAIT); 370 if (!ctx_entry) { 371 DRM_DEBUG("out of memory\n"); 372 return -ENOMEM; 373 } 374 375 INIT_LIST_HEAD(&ctx_entry->head); 376 ctx_entry->handle = ctx->handle; 377 ctx_entry->tag = file_priv; 378 379 DRM_LOCK(dev); 380 list_add(&ctx_entry->head, &dev->ctxlist); 381 ++dev->ctx_count; 382 DRM_UNLOCK(dev); 383 384 return 0; 385 } 386 387 int drm_modctx(struct drm_device *dev, void *data, struct drm_file *file_priv) 388 { 389 /* This does nothing */ 390 return 0; 391 } 392 393 /** 394 * Get context. 395 * 396 * \param inode device inode. 397 * \param file_priv DRM file private. 398 * \param cmd command. 399 * \param arg user argument pointing to a drm_ctx structure. 400 * \return zero on success or a negative number on failure. 401 */ 402 int drm_getctx(struct drm_device *dev, void *data, struct drm_file *file_priv) 403 { 404 struct drm_ctx *ctx = data; 405 406 /* This is 0, because we don't handle any context flags */ 407 ctx->flags = 0; 408 409 return 0; 410 } 411 412 /** 413 * Switch context. 414 * 415 * \param inode device inode. 416 * \param file_priv DRM file private. 417 * \param cmd command. 418 * \param arg user argument pointing to a drm_ctx structure. 419 * \return zero on success or a negative number on failure. 420 * 421 * Calls context_switch(). 422 */ 423 int drm_switchctx(struct drm_device *dev, void *data, 424 struct drm_file *file_priv) 425 { 426 struct drm_ctx *ctx = data; 427 428 DRM_DEBUG("%d\n", ctx->handle); 429 return drm_context_switch(dev, dev->last_context, ctx->handle); 430 } 431 432 /** 433 * New context. 434 * 435 * \param inode device inode. 436 * \param file_priv DRM file private. 437 * \param cmd command. 438 * \param arg user argument pointing to a drm_ctx structure. 439 * \return zero on success or a negative number on failure. 440 * 441 * Calls context_switch_complete(). 442 */ 443 int drm_newctx(struct drm_device *dev, void *data, 444 struct drm_file *file_priv) 445 { 446 struct drm_ctx *ctx = data; 447 448 DRM_DEBUG("%d\n", ctx->handle); 449 drm_context_switch_complete(dev, file_priv, ctx->handle); 450 451 return 0; 452 } 453 454 /** 455 * Remove context. 456 * 457 * \param inode device inode. 458 * \param file_priv DRM file private. 459 * \param cmd command. 460 * \param arg user argument pointing to a drm_ctx structure. 461 * \return zero on success or a negative number on failure. 462 * 463 * If not the special kernel context, calls ctxbitmap_free() to free the specified context. 464 */ 465 int drm_rmctx(struct drm_device *dev, void *data, 466 struct drm_file *file_priv) 467 { 468 struct drm_ctx *ctx = data; 469 470 DRM_DEBUG("%d\n", ctx->handle); 471 if (ctx->handle != DRM_KERNEL_CONTEXT) { 472 if (dev->driver->context_dtor) 473 dev->driver->context_dtor(dev, ctx->handle); 474 drm_ctxbitmap_free(dev, ctx->handle); 475 } 476 477 DRM_LOCK(dev); 478 if (!list_empty(&dev->ctxlist)) { 479 struct drm_ctx_list *pos, *n; 480 481 list_for_each_entry_safe(pos, n, &dev->ctxlist, head) { 482 if (pos->handle == ctx->handle) { 483 list_del(&pos->head); 484 free(pos, DRM_MEM_CTXBITMAP); 485 --dev->ctx_count; 486 } 487 } 488 } 489 DRM_UNLOCK(dev); 490 491 return 0; 492 } 493 494 /*@}*/ 495