1280183Sdumbbell/** 2280183Sdumbbell * \file drm_context.c 3280183Sdumbbell * IOCTLs for generic contexts 4280183Sdumbbell * 5280183Sdumbbell * \author Rickard E. (Rik) Faith <faith@valinux.com> 6280183Sdumbbell * \author Gareth Hughes <gareth@valinux.com> 7280183Sdumbbell */ 8280183Sdumbbell 9280183Sdumbbell/* 10280183Sdumbbell * Created: Fri Nov 24 18:31:37 2000 by gareth@valinux.com 11280183Sdumbbell * 12235783Skib * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas. 13235783Skib * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. 14235783Skib * All Rights Reserved. 15235783Skib * 16235783Skib * Permission is hereby granted, free of charge, to any person obtaining a 17235783Skib * copy of this software and associated documentation files (the "Software"), 18235783Skib * to deal in the Software without restriction, including without limitation 19235783Skib * the rights to use, copy, modify, merge, publish, distribute, sublicense, 20235783Skib * and/or sell copies of the Software, and to permit persons to whom the 21235783Skib * Software is furnished to do so, subject to the following conditions: 22235783Skib * 23235783Skib * The above copyright notice and this permission notice (including the next 24235783Skib * paragraph) shall be included in all copies or substantial portions of the 25235783Skib * Software. 26235783Skib * 27235783Skib * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 28235783Skib * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 29235783Skib * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 30235783Skib * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 31235783Skib * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 32235783Skib * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 33235783Skib * OTHER DEALINGS IN THE SOFTWARE. 34235783Skib */ 35235783Skib 36235783Skib#include <sys/cdefs.h> 37235783Skib__FBSDID("$FreeBSD$"); 38235783Skib 39280183Sdumbbell/* 40280183Sdumbbell * ChangeLog: 41280183Sdumbbell * 2001-11-16 Torsten Duwe <duwe@caldera.de> 42280183Sdumbbell * added context constructor/destructor hooks, 43280183Sdumbbell * needed by SiS driver's memory management. 44235783Skib */ 45235783Skib 46235783Skib#include <dev/drm2/drmP.h> 47235783Skib 48280183Sdumbbell/******************************************************************/ 49280183Sdumbbell/** \name Context bitmap support */ 50280183Sdumbbell/*@{*/ 51280183Sdumbbell 52280183Sdumbbell/** 53280183Sdumbbell * Free a handle from the context bitmap. 54280183Sdumbbell * 55280183Sdumbbell * \param dev DRM device. 56280183Sdumbbell * \param ctx_handle context handle. 57280183Sdumbbell * 58280183Sdumbbell * Clears the bit specified by \p ctx_handle in drm_device::ctx_bitmap and the entry 59280183Sdumbbell * in drm_device::ctx_idr, while holding the drm_device::struct_mutex 60280183Sdumbbell * lock. 61235783Skib */ 62280183Sdumbbellvoid drm_ctxbitmap_free(struct drm_device * dev, int ctx_handle) 63235783Skib{ 64280183Sdumbbell if (ctx_handle < 0 || ctx_handle >= DRM_MAX_CTXBITMAP || 65235783Skib dev->ctx_bitmap == NULL) { 66235783Skib DRM_ERROR("Attempt to free invalid context handle: %d\n", 67235783Skib ctx_handle); 68235783Skib return; 69235783Skib } 70235783Skib 71235783Skib DRM_LOCK(dev); 72235783Skib clear_bit(ctx_handle, dev->ctx_bitmap); 73235783Skib dev->context_sareas[ctx_handle] = NULL; 74235783Skib DRM_UNLOCK(dev); 75235783Skib} 76235783Skib 77280183Sdumbbell/** 78280183Sdumbbell * Context bitmap allocation. 79280183Sdumbbell * 80280183Sdumbbell * \param dev DRM device. 81280183Sdumbbell * \return (non-negative) context handle on success or a negative number on failure. 82280183Sdumbbell * 83280183Sdumbbell * Allocate a new idr from drm_device::ctx_idr while holding the 84280183Sdumbbell * drm_device::struct_mutex lock. 85280183Sdumbbell */ 86280183Sdumbbellstatic int drm_ctxbitmap_next(struct drm_device * dev) 87235783Skib{ 88235783Skib int bit; 89235783Skib 90235783Skib if (dev->ctx_bitmap == NULL) 91235783Skib return -1; 92235783Skib 93235783Skib DRM_LOCK(dev); 94235783Skib bit = find_first_zero_bit(dev->ctx_bitmap, DRM_MAX_CTXBITMAP); 95235783Skib if (bit >= DRM_MAX_CTXBITMAP) { 96235783Skib DRM_UNLOCK(dev); 97235783Skib return -1; 98235783Skib } 99235783Skib 100235783Skib set_bit(bit, dev->ctx_bitmap); 101235783Skib DRM_DEBUG("bit : %d\n", bit); 102235783Skib if ((bit+1) > dev->max_context) { 103280183Sdumbbell struct drm_local_map **ctx_sareas; 104235783Skib int max_ctx = (bit+1); 105235783Skib 106235783Skib ctx_sareas = realloc(dev->context_sareas, 107235783Skib max_ctx * sizeof(*dev->context_sareas), 108235783Skib DRM_MEM_SAREA, M_NOWAIT); 109235783Skib if (ctx_sareas == NULL) { 110235783Skib clear_bit(bit, dev->ctx_bitmap); 111235783Skib DRM_DEBUG("failed to allocate bit : %d\n", bit); 112235783Skib DRM_UNLOCK(dev); 113235783Skib return -1; 114235783Skib } 115235783Skib dev->max_context = max_ctx; 116235783Skib dev->context_sareas = ctx_sareas; 117235783Skib dev->context_sareas[bit] = NULL; 118235783Skib } 119235783Skib DRM_UNLOCK(dev); 120235783Skib return bit; 121235783Skib} 122235783Skib 123280183Sdumbbell/** 124280183Sdumbbell * Context bitmap initialization. 125280183Sdumbbell * 126280183Sdumbbell * \param dev DRM device. 127280183Sdumbbell * 128280183Sdumbbell * Initialise the drm_device::ctx_idr 129280183Sdumbbell */ 130280183Sdumbbellint drm_ctxbitmap_init(struct drm_device * dev) 131235783Skib{ 132235783Skib int i; 133235783Skib int temp; 134235783Skib 135235783Skib DRM_LOCK(dev); 136235783Skib dev->ctx_bitmap = malloc(PAGE_SIZE, DRM_MEM_CTXBITMAP, 137235783Skib M_NOWAIT | M_ZERO); 138235783Skib if (dev->ctx_bitmap == NULL) { 139235783Skib DRM_UNLOCK(dev); 140235783Skib return ENOMEM; 141235783Skib } 142235783Skib dev->context_sareas = NULL; 143235783Skib dev->max_context = -1; 144235783Skib DRM_UNLOCK(dev); 145235783Skib 146235783Skib for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) { 147235783Skib temp = drm_ctxbitmap_next(dev); 148235783Skib DRM_DEBUG("drm_ctxbitmap_init : %d\n", temp); 149235783Skib } 150235783Skib 151235783Skib return 0; 152235783Skib} 153235783Skib 154280183Sdumbbell/** 155280183Sdumbbell * Context bitmap cleanup. 156280183Sdumbbell * 157280183Sdumbbell * \param dev DRM device. 158280183Sdumbbell * 159280183Sdumbbell * Free all idr members using drm_ctx_sarea_free helper function 160280183Sdumbbell * while holding the drm_device::struct_mutex lock. 161280183Sdumbbell */ 162280183Sdumbbellvoid drm_ctxbitmap_cleanup(struct drm_device * dev) 163235783Skib{ 164235783Skib DRM_LOCK(dev); 165235783Skib if (dev->context_sareas != NULL) 166235783Skib free(dev->context_sareas, DRM_MEM_SAREA); 167235783Skib free(dev->ctx_bitmap, DRM_MEM_CTXBITMAP); 168235783Skib DRM_UNLOCK(dev); 169235783Skib} 170235783Skib 171280183Sdumbbell/*@}*/ 172280183Sdumbbell 173280183Sdumbbell/******************************************************************/ 174280183Sdumbbell/** \name Per Context SAREA Support */ 175280183Sdumbbell/*@{*/ 176280183Sdumbbell 177280183Sdumbbell/** 178280183Sdumbbell * Get per-context SAREA. 179280183Sdumbbell * 180280183Sdumbbell * \param inode device inode. 181280183Sdumbbell * \param file_priv DRM file private. 182280183Sdumbbell * \param cmd command. 183280183Sdumbbell * \param arg user argument pointing to a drm_ctx_priv_map structure. 184280183Sdumbbell * \return zero on success or a negative number on failure. 185280183Sdumbbell * 186280183Sdumbbell * Gets the map from drm_device::ctx_idr with the handle specified and 187280183Sdumbbell * returns its handle. 188235783Skib */ 189235783Skibint drm_getsareactx(struct drm_device *dev, void *data, 190235783Skib struct drm_file *file_priv) 191235783Skib{ 192235783Skib struct drm_ctx_priv_map *request = data; 193280183Sdumbbell struct drm_local_map *map; 194235783Skib 195235783Skib DRM_LOCK(dev); 196235783Skib if (dev->max_context < 0 || 197235783Skib request->ctx_id >= (unsigned) dev->max_context) { 198235783Skib DRM_UNLOCK(dev); 199235783Skib return EINVAL; 200235783Skib } 201235783Skib 202235783Skib map = dev->context_sareas[request->ctx_id]; 203235783Skib DRM_UNLOCK(dev); 204235783Skib 205235783Skib request->handle = (void *)map->handle; 206235783Skib 207235783Skib return 0; 208235783Skib} 209235783Skib 210280183Sdumbbell/** 211280183Sdumbbell * Set per-context SAREA. 212280183Sdumbbell * 213280183Sdumbbell * \param inode device inode. 214280183Sdumbbell * \param file_priv DRM file private. 215280183Sdumbbell * \param cmd command. 216280183Sdumbbell * \param arg user argument pointing to a drm_ctx_priv_map structure. 217280183Sdumbbell * \return zero on success or a negative number on failure. 218280183Sdumbbell * 219280183Sdumbbell * Searches the mapping specified in \p arg and update the entry in 220280183Sdumbbell * drm_device::ctx_idr with it. 221280183Sdumbbell */ 222235783Skibint drm_setsareactx(struct drm_device *dev, void *data, 223235783Skib struct drm_file *file_priv) 224235783Skib{ 225235783Skib struct drm_ctx_priv_map *request = data; 226280183Sdumbbell struct drm_local_map *map = NULL; 227280183Sdumbbell struct drm_map_list *r_list = NULL; 228235783Skib 229235783Skib DRM_LOCK(dev); 230280183Sdumbbell list_for_each_entry(r_list, &dev->maplist, head) { 231280183Sdumbbell if (r_list->map 232280183Sdumbbell && r_list->user_token == (unsigned long) request->handle) { 233235783Skib if (dev->max_context < 0) 234235783Skib goto bad; 235235783Skib if (request->ctx_id >= (unsigned) dev->max_context) 236235783Skib goto bad; 237235783Skib dev->context_sareas[request->ctx_id] = map; 238235783Skib DRM_UNLOCK(dev); 239235783Skib return 0; 240235783Skib } 241235783Skib } 242235783Skib 243235783Skibbad: 244235783Skib DRM_UNLOCK(dev); 245235783Skib return EINVAL; 246235783Skib} 247235783Skib 248280183Sdumbbell/*@}*/ 249280183Sdumbbell 250280183Sdumbbell/******************************************************************/ 251280183Sdumbbell/** \name The actual DRM context handling routines */ 252280183Sdumbbell/*@{*/ 253280183Sdumbbell 254280183Sdumbbell/** 255280183Sdumbbell * Switch context. 256280183Sdumbbell * 257280183Sdumbbell * \param dev DRM device. 258280183Sdumbbell * \param old old context handle. 259280183Sdumbbell * \param new new context handle. 260280183Sdumbbell * \return zero on success or a negative number on failure. 261280183Sdumbbell * 262280183Sdumbbell * Attempt to set drm_device::context_flag. 263235783Skib */ 264280183Sdumbbellstatic int drm_context_switch(struct drm_device * dev, int old, int new) 265235783Skib{ 266280183Sdumbbell if (test_and_set_bit(0, &dev->context_flag)) { 267235783Skib DRM_ERROR("Reentering -- FIXME\n"); 268280183Sdumbbell return -EBUSY; 269235783Skib } 270235783Skib 271235783Skib DRM_DEBUG("Context switch from %d to %d\n", old, new); 272235783Skib 273235783Skib if (new == dev->last_context) { 274280183Sdumbbell clear_bit(0, &dev->context_flag); 275235783Skib return 0; 276235783Skib } 277235783Skib 278235783Skib return 0; 279235783Skib} 280235783Skib 281280183Sdumbbell/** 282280183Sdumbbell * Complete context switch. 283280183Sdumbbell * 284280183Sdumbbell * \param dev DRM device. 285280183Sdumbbell * \param new new context handle. 286280183Sdumbbell * \return zero on success or a negative number on failure. 287280183Sdumbbell * 288280183Sdumbbell * Updates drm_device::last_context and drm_device::last_switch. Verifies the 289280183Sdumbbell * hardware lock is held, clears the drm_device::context_flag and wakes up 290280183Sdumbbell * drm_device::context_wait. 291280183Sdumbbell */ 292280183Sdumbbellstatic int drm_context_switch_complete(struct drm_device *dev, 293280183Sdumbbell struct drm_file *file_priv, int new) 294235783Skib{ 295280183Sdumbbell dev->last_context = new; /* PRE/POST: This is the _only_ writer. */ 296280183Sdumbbell dev->last_switch = jiffies; 297235783Skib 298280183Sdumbbell if (!_DRM_LOCK_IS_HELD(file_priv->master->lock.hw_lock->lock)) { 299235783Skib DRM_ERROR("Lock isn't held after context switch\n"); 300235783Skib } 301235783Skib 302235783Skib /* If a context switch is ever initiated 303235783Skib when the kernel holds the lock, release 304235783Skib that lock here. */ 305280183Sdumbbell clear_bit(0, &dev->context_flag); 306280183Sdumbbell wakeup(&dev->context_wait); 307235783Skib 308235783Skib return 0; 309235783Skib} 310235783Skib 311280183Sdumbbell/** 312280183Sdumbbell * Reserve contexts. 313280183Sdumbbell * 314280183Sdumbbell * \param inode device inode. 315280183Sdumbbell * \param file_priv DRM file private. 316280183Sdumbbell * \param cmd command. 317280183Sdumbbell * \param arg user argument pointing to a drm_ctx_res structure. 318280183Sdumbbell * \return zero on success or a negative number on failure. 319280183Sdumbbell */ 320280183Sdumbbellint drm_resctx(struct drm_device *dev, void *data, 321280183Sdumbbell struct drm_file *file_priv) 322235783Skib{ 323235783Skib struct drm_ctx_res *res = data; 324235783Skib struct drm_ctx ctx; 325235783Skib int i; 326235783Skib 327235783Skib if (res->count >= DRM_RESERVED_CONTEXTS) { 328280183Sdumbbell memset(&ctx, 0, sizeof(ctx)); 329235783Skib for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) { 330235783Skib ctx.handle = i; 331280183Sdumbbell if (copy_to_user(&res->contexts[i], &ctx, sizeof(ctx))) 332280183Sdumbbell return -EFAULT; 333235783Skib } 334235783Skib } 335235783Skib res->count = DRM_RESERVED_CONTEXTS; 336235783Skib 337235783Skib return 0; 338235783Skib} 339235783Skib 340280183Sdumbbell/** 341280183Sdumbbell * Add context. 342280183Sdumbbell * 343280183Sdumbbell * \param inode device inode. 344280183Sdumbbell * \param file_priv DRM file private. 345280183Sdumbbell * \param cmd command. 346280183Sdumbbell * \param arg user argument pointing to a drm_ctx structure. 347280183Sdumbbell * \return zero on success or a negative number on failure. 348280183Sdumbbell * 349280183Sdumbbell * Get a new handle for the context and copy to userspace. 350280183Sdumbbell */ 351280183Sdumbbellint drm_addctx(struct drm_device *dev, void *data, 352280183Sdumbbell struct drm_file *file_priv) 353235783Skib{ 354280183Sdumbbell struct drm_ctx_list *ctx_entry; 355235783Skib struct drm_ctx *ctx = data; 356235783Skib 357235783Skib ctx->handle = drm_ctxbitmap_next(dev); 358235783Skib if (ctx->handle == DRM_KERNEL_CONTEXT) { 359235783Skib /* Skip kernel's context and get a new one. */ 360235783Skib ctx->handle = drm_ctxbitmap_next(dev); 361235783Skib } 362235783Skib DRM_DEBUG("%d\n", ctx->handle); 363235783Skib if (ctx->handle == -1) { 364235783Skib DRM_DEBUG("Not enough free contexts.\n"); 365235783Skib /* Should this return -EBUSY instead? */ 366280183Sdumbbell return -ENOMEM; 367235783Skib } 368235783Skib 369280183Sdumbbell ctx_entry = malloc(sizeof(*ctx_entry), DRM_MEM_CTXBITMAP, M_NOWAIT); 370280183Sdumbbell if (!ctx_entry) { 371280183Sdumbbell DRM_DEBUG("out of memory\n"); 372280183Sdumbbell return -ENOMEM; 373235783Skib } 374235783Skib 375280183Sdumbbell INIT_LIST_HEAD(&ctx_entry->head); 376280183Sdumbbell ctx_entry->handle = ctx->handle; 377280183Sdumbbell ctx_entry->tag = file_priv; 378280183Sdumbbell 379280183Sdumbbell DRM_LOCK(dev); 380280183Sdumbbell list_add(&ctx_entry->head, &dev->ctxlist); 381280183Sdumbbell ++dev->ctx_count; 382280183Sdumbbell DRM_UNLOCK(dev); 383280183Sdumbbell 384235783Skib return 0; 385235783Skib} 386235783Skib 387235783Skibint drm_modctx(struct drm_device *dev, void *data, struct drm_file *file_priv) 388235783Skib{ 389235783Skib /* This does nothing */ 390235783Skib return 0; 391235783Skib} 392235783Skib 393280183Sdumbbell/** 394280183Sdumbbell * Get context. 395280183Sdumbbell * 396280183Sdumbbell * \param inode device inode. 397280183Sdumbbell * \param file_priv DRM file private. 398280183Sdumbbell * \param cmd command. 399280183Sdumbbell * \param arg user argument pointing to a drm_ctx structure. 400280183Sdumbbell * \return zero on success or a negative number on failure. 401280183Sdumbbell */ 402235783Skibint drm_getctx(struct drm_device *dev, void *data, struct drm_file *file_priv) 403235783Skib{ 404235783Skib struct drm_ctx *ctx = data; 405235783Skib 406235783Skib /* This is 0, because we don't handle any context flags */ 407235783Skib ctx->flags = 0; 408235783Skib 409235783Skib return 0; 410235783Skib} 411235783Skib 412280183Sdumbbell/** 413280183Sdumbbell * Switch context. 414280183Sdumbbell * 415280183Sdumbbell * \param inode device inode. 416280183Sdumbbell * \param file_priv DRM file private. 417280183Sdumbbell * \param cmd command. 418280183Sdumbbell * \param arg user argument pointing to a drm_ctx structure. 419280183Sdumbbell * \return zero on success or a negative number on failure. 420280183Sdumbbell * 421280183Sdumbbell * Calls context_switch(). 422280183Sdumbbell */ 423235783Skibint drm_switchctx(struct drm_device *dev, void *data, 424235783Skib struct drm_file *file_priv) 425235783Skib{ 426235783Skib struct drm_ctx *ctx = data; 427235783Skib 428235783Skib DRM_DEBUG("%d\n", ctx->handle); 429235783Skib return drm_context_switch(dev, dev->last_context, ctx->handle); 430235783Skib} 431235783Skib 432280183Sdumbbell/** 433280183Sdumbbell * New context. 434280183Sdumbbell * 435280183Sdumbbell * \param inode device inode. 436280183Sdumbbell * \param file_priv DRM file private. 437280183Sdumbbell * \param cmd command. 438280183Sdumbbell * \param arg user argument pointing to a drm_ctx structure. 439280183Sdumbbell * \return zero on success or a negative number on failure. 440280183Sdumbbell * 441280183Sdumbbell * Calls context_switch_complete(). 442280183Sdumbbell */ 443280183Sdumbbellint drm_newctx(struct drm_device *dev, void *data, 444280183Sdumbbell struct drm_file *file_priv) 445235783Skib{ 446235783Skib struct drm_ctx *ctx = data; 447235783Skib 448235783Skib DRM_DEBUG("%d\n", ctx->handle); 449280183Sdumbbell drm_context_switch_complete(dev, file_priv, ctx->handle); 450235783Skib 451235783Skib return 0; 452235783Skib} 453235783Skib 454280183Sdumbbell/** 455280183Sdumbbell * Remove context. 456280183Sdumbbell * 457280183Sdumbbell * \param inode device inode. 458280183Sdumbbell * \param file_priv DRM file private. 459280183Sdumbbell * \param cmd command. 460280183Sdumbbell * \param arg user argument pointing to a drm_ctx structure. 461280183Sdumbbell * \return zero on success or a negative number on failure. 462280183Sdumbbell * 463280183Sdumbbell * If not the special kernel context, calls ctxbitmap_free() to free the specified context. 464280183Sdumbbell */ 465280183Sdumbbellint drm_rmctx(struct drm_device *dev, void *data, 466280183Sdumbbell struct drm_file *file_priv) 467235783Skib{ 468235783Skib struct drm_ctx *ctx = data; 469235783Skib 470235783Skib DRM_DEBUG("%d\n", ctx->handle); 471235783Skib if (ctx->handle != DRM_KERNEL_CONTEXT) { 472280183Sdumbbell if (dev->driver->context_dtor) 473235783Skib dev->driver->context_dtor(dev, ctx->handle); 474235783Skib drm_ctxbitmap_free(dev, ctx->handle); 475235783Skib } 476235783Skib 477280183Sdumbbell DRM_LOCK(dev); 478280183Sdumbbell if (!list_empty(&dev->ctxlist)) { 479280183Sdumbbell struct drm_ctx_list *pos, *n; 480280183Sdumbbell 481280183Sdumbbell list_for_each_entry_safe(pos, n, &dev->ctxlist, head) { 482280183Sdumbbell if (pos->handle == ctx->handle) { 483280183Sdumbbell list_del(&pos->head); 484280183Sdumbbell free(pos, DRM_MEM_CTXBITMAP); 485280183Sdumbbell --dev->ctx_count; 486280183Sdumbbell } 487280183Sdumbbell } 488280183Sdumbbell } 489280183Sdumbbell DRM_UNLOCK(dev); 490280183Sdumbbell 491235783Skib return 0; 492235783Skib} 493280183Sdumbbell 494280183Sdumbbell/*@}*/ 495