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