开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
drm_context.h
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：20k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

drm_context.h：源码内容
  1. /* drm_context.h -- IOCTLs for generic contexts -*- linux-c -*-
  2.  * Created: Fri Nov 24 18:31:37 2000 by gareth@valinux.com
  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.  * Permission is hereby granted, free of charge, to any person obtaining a
  9.  * copy of this software and associated documentation files (the "Software"),
  10.  * to deal in the Software without restriction, including without limitation
  11.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12.  * and/or sell copies of the Software, and to permit persons to whom the
  13.  * Software is furnished to do so, subject to the following conditions:
  14.  *
  15.  * The above copyright notice and this permission notice (including the next
  16.  * paragraph) shall be included in all copies or substantial portions of the
  17.  * Software.
  18.  *
  19.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22.  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  23.  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  24.  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  25.  * OTHER DEALINGS IN THE SOFTWARE.
  26.  *
  27.  * Authors:
  28.  *    Rickard E. (Rik) Faith <faith@valinux.com>
  29.  *    Gareth Hughes <gareth@valinux.com>
  30.  * ChangeLog:
  31.  *  2001-11-16 Torsten Duwe <duwe@caldera.de>
  32.  * added context constructor/destructor hooks,
  33.  * needed by SiS driver's memory management.
  34.  */
  36. #define __NO_VERSION__
  37. #include "drmP.h"
  39. #if __HAVE_CTX_BITMAP
  41. /* ================================================================
  42.  * Context bitmap support
  43.  */
  45. void DRM(ctxbitmap_free)( drm_device_t *dev, int ctx_handle )
  46. {
  47. if ( ctx_handle < 0 ) goto failed;
  48. if ( !dev->ctx_bitmap ) goto failed;
  50. if ( ctx_handle < DRM_MAX_CTXBITMAP ) {
  51. down(&dev->struct_sem);
  52. clear_bit( ctx_handle, dev->ctx_bitmap );
  53. dev->context_sareas[ctx_handle] = NULL;
  54. up(&dev->struct_sem);
  55. return;
  56. }
  57. failed:
  58.         DRM_ERROR( "Attempt to free invalid context handle: %dn",
  59.    ctx_handle );
  60.         return;
  61. }
  63. int DRM(ctxbitmap_next)( drm_device_t *dev )
  64. {
  65. int bit;
  67. if(!dev->ctx_bitmap) return -1;
  69. down(&dev->struct_sem);
  70. bit = find_first_zero_bit( dev->ctx_bitmap, DRM_MAX_CTXBITMAP );
  71. if ( bit < DRM_MAX_CTXBITMAP ) {
  72. set_bit( bit, dev->ctx_bitmap );
  73.     DRM_DEBUG( "drm_ctxbitmap_next bit : %dn", bit );
  74. if((bit+1) > dev->max_context) {
  75. dev->max_context = (bit+1);
  76. if(dev->context_sareas) {
  77. drm_map_t **ctx_sareas;
  79. ctx_sareas = DRM(realloc)(dev->context_sareas,
  80. (dev->max_context - 1) * 
  81. sizeof(*dev->context_sareas),
  82. dev->max_context * 
  83. sizeof(*dev->context_sareas),
  84. DRM_MEM_MAPS);
  85. if(!ctx_sareas) {
  86. clear_bit(bit, dev->ctx_bitmap);
  87. up(&dev->struct_sem);
  88. return -1;
  89. }
  90. dev->context_sareas = ctx_sareas;
  91. dev->context_sareas[bit] = NULL;
  92. } else {
  93. /* max_context == 1 at this point */
  94. dev->context_sareas = DRM(alloc)(
  95. dev->max_context * 
  96. sizeof(*dev->context_sareas),
  97. DRM_MEM_MAPS);
  98. if(!dev->context_sareas) {
  99. clear_bit(bit, dev->ctx_bitmap);
  100. up(&dev->struct_sem);
  101. return -1;
  102. }
  103. dev->context_sareas[bit] = NULL;
  104. }
  105. }
  106. up(&dev->struct_sem);
  107. return bit;
  108. }
  109. up(&dev->struct_sem);
  110. return -1;
  111. }
  113. int DRM(ctxbitmap_init)( drm_device_t *dev )
  114. {
  115. int i;
  116.     int temp;
  118. down(&dev->struct_sem);
  119. dev->ctx_bitmap = (unsigned long *) DRM(alloc)( PAGE_SIZE,
  120. DRM_MEM_CTXBITMAP );
  121. if ( dev->ctx_bitmap == NULL ) {
  122. up(&dev->struct_sem);
  123. return -ENOMEM;
  124. }
  125. memset( (void *)dev->ctx_bitmap, 0, PAGE_SIZE );
  126. dev->context_sareas = NULL;
  127. dev->max_context = -1;
  128. up(&dev->struct_sem);
  130. for ( i = 0 ; i < DRM_RESERVED_CONTEXTS ; i++ ) {
  131. temp = DRM(ctxbitmap_next)( dev );
  132.     DRM_DEBUG( "drm_ctxbitmap_init : %dn", temp );
  133. }
  135. return 0;
  136. }
  138. void DRM(ctxbitmap_cleanup)( drm_device_t *dev )
  139. {
  140. down(&dev->struct_sem);
  141. if( dev->context_sareas ) DRM(free)( dev->context_sareas,
  142.      sizeof(*dev->context_sareas) * 
  143.      dev->max_context,
  144.      DRM_MEM_MAPS );
  145. DRM(free)( (void *)dev->ctx_bitmap, PAGE_SIZE, DRM_MEM_CTXBITMAP );
  146. up(&dev->struct_sem);
  147. }
  149. /* ================================================================
  150.  * Per Context SAREA Support
  151.  */
  153. int DRM(getsareactx)(struct inode *inode, struct file *filp,
  154.      unsigned int cmd, unsigned long arg)
  155. {
  156. drm_file_t *priv = filp->private_data;
  157. drm_device_t *dev = priv->dev;
  158. drm_ctx_priv_map_t request;
  159. drm_map_t *map;
  161. if (copy_from_user(&request,
  162.    (drm_ctx_priv_map_t *)arg,
  163.    sizeof(request)))
  164. return -EFAULT;
  166. down(&dev->struct_sem);
  167. if (dev->max_context < 0 || request.ctx_id >= (unsigned) dev->max_context) {
  168. up(&dev->struct_sem);
  169. return -EINVAL;
  170. }
  172. map = dev->context_sareas[request.ctx_id];
  173. up(&dev->struct_sem);
  175. request.handle = map->handle;
  176. if (copy_to_user((drm_ctx_priv_map_t *)arg, &request, sizeof(request)))
  177. return -EFAULT;
  178. return 0;
  179. }
  181. int DRM(setsareactx)(struct inode *inode, struct file *filp,
  182.      unsigned int cmd, unsigned long arg)
  183. {
  184. drm_file_t *priv = filp->private_data;
  185. drm_device_t *dev = priv->dev;
  186. drm_ctx_priv_map_t request;
  187. drm_map_t *map = NULL;
  188. drm_map_list_t *r_list = NULL;
  189. struct list_head *list;
  191. if (copy_from_user(&request,
  192.    (drm_ctx_priv_map_t *)arg,
  193.    sizeof(request)))
  194. return -EFAULT;
  196. down(&dev->struct_sem);
  197. list_for_each(list, &dev->maplist->head) {
  198. r_list = (drm_map_list_t *)list;
  199. if(r_list->map &&
  200.    r_list->map->handle == request.handle)
  201. goto found;
  202. }
  203. bad:
  204. up(&dev->struct_sem);
  205. return -EINVAL;
  207. found:
  208. map = r_list->map;
  209. if (!map) goto bad;
  210. if (dev->max_context < 0)
  211. goto bad;
  212. if (request.ctx_id >= (unsigned) dev->max_context)
  213. goto bad;
  214. dev->context_sareas[request.ctx_id] = map;
  215. up(&dev->struct_sem);
  216. return 0;
  217. }
  219. /* ================================================================
  220.  * The actual DRM context handling routines
  221.  */
  223. int DRM(context_switch)( drm_device_t *dev, int old, int new )
  224. {
  225.         char buf[64];
  227.         if ( test_and_set_bit( 0, &dev->context_flag ) ) {
  228.                 DRM_ERROR( "Reentering -- FIXMEn" );
  229.                 return -EBUSY;
  230.         }
  232. #if __HAVE_DMA_HISTOGRAM
  233.         dev->ctx_start = get_cycles();
  234. #endif
  236.         DRM_DEBUG( "Context switch from %d to %dn", old, new );
  238.         if ( new == dev->last_context ) {
  239.                 clear_bit( 0, &dev->context_flag );
  240.                 return 0;
  241.         }
  243.         if ( DRM(flags) & DRM_FLAG_NOCTX ) {
  244.                 DRM(context_switch_complete)( dev, new );
  245.         } else {
  246.                 sprintf( buf, "C %d %dn", old, new );
  247.                 DRM(write_string)( dev, buf );
  248.         }
  250.         return 0;
  251. }
  253. int DRM(context_switch_complete)( drm_device_t *dev, int new )
  254. {
  255.         dev->last_context = new;  /* PRE/POST: This is the _only_ writer. */
  256.         dev->last_switch  = jiffies;
  258.         if ( !_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock) ) {
  259.                 DRM_ERROR( "Lock isn't held after context switchn" );
  260.         }
  262. /* If a context switch is ever initiated
  263.                                    when the kernel holds the lock, release
  264.                                    that lock here. */
  265. #if __HAVE_DMA_HISTOGRAM
  266.         atomic_inc( &dev->histo.ctx[DRM(histogram_slot)(get_cycles()
  267. - dev->ctx_start)] );
  269. #endif
  270.         clear_bit( 0, &dev->context_flag );
  271.         wake_up( &dev->context_wait );
  273.         return 0;
  274. }
  276. int DRM(resctx)( struct inode *inode, struct file *filp,
  277.  unsigned int cmd, unsigned long arg )
  278. {
  279. drm_ctx_res_t res;
  280. drm_ctx_t ctx;
  281. int i;
  283. if ( copy_from_user( &res, (drm_ctx_res_t *)arg, sizeof(res) ) )
  284. return -EFAULT;
  286. if ( res.count >= DRM_RESERVED_CONTEXTS ) {
  287. memset( &ctx, 0, sizeof(ctx) );
  288. for ( i = 0 ; i < DRM_RESERVED_CONTEXTS ; i++ ) {
  289. ctx.handle = i;
  290. if ( copy_to_user( &res.contexts[i],
  291.    &i, sizeof(i) ) )
  292. return -EFAULT;
  293. }
  294. }
  295. res.count = DRM_RESERVED_CONTEXTS;
  297. if ( copy_to_user( (drm_ctx_res_t *)arg, &res, sizeof(res) ) )
  298. return -EFAULT;
  299. return 0;
  300. }
  302. int DRM(addctx)( struct inode *inode, struct file *filp,
  303.  unsigned int cmd, unsigned long arg )
  304. {
  305. drm_file_t *priv = filp->private_data;
  306. drm_device_t *dev = priv->dev;
  307. drm_ctx_t ctx;
  309. if ( copy_from_user( &ctx, (drm_ctx_t *)arg, sizeof(ctx) ) )
  310. return -EFAULT;
  312. ctx.handle = DRM(ctxbitmap_next)( dev );
  313. if ( ctx.handle == DRM_KERNEL_CONTEXT ) {
  314. /* Skip kernel's context and get a new one. */
  315. ctx.handle = DRM(ctxbitmap_next)( dev );
  316. }
  317. DRM_DEBUG( "%dn", ctx.handle );
  318. if ( ctx.handle == -1 ) {
  319. DRM_DEBUG( "Not enough free contexts.n" );
  320. /* Should this return -EBUSY instead? */
  321. return -ENOMEM;
  322. }
  323. #ifdef DRIVER_CTX_CTOR
  324. if ( ctx.handle != DRM_KERNEL_CONTEXT )
  325. DRIVER_CTX_CTOR(ctx.handle); /* XXX: also pass dev ? */
  326. #endif
  328. if ( copy_to_user( (drm_ctx_t *)arg, &ctx, sizeof(ctx) ) )
  329. return -EFAULT;
  330. return 0;
  331. }
  333. int DRM(modctx)( struct inode *inode, struct file *filp,
  334.  unsigned int cmd, unsigned long arg )
  335. {
  336. /* This does nothing */
  337. return 0;
  338. }
  340. int DRM(getctx)( struct inode *inode, struct file *filp,
  341.  unsigned int cmd, unsigned long arg )
  342. {
  343. drm_ctx_t ctx;
  345. if ( copy_from_user( &ctx, (drm_ctx_t*)arg, sizeof(ctx) ) )
  346. return -EFAULT;
  348. /* This is 0, because we don't handle any context flags */
  349. ctx.flags = 0;
  351. if ( copy_to_user( (drm_ctx_t*)arg, &ctx, sizeof(ctx) ) )
  352. return -EFAULT;
  353. return 0;
  354. }
  356. int DRM(switchctx)( struct inode *inode, struct file *filp,
  357.     unsigned int cmd, unsigned long arg )
  358. {
  359. drm_file_t *priv = filp->private_data;
  360. drm_device_t *dev = priv->dev;
  361. drm_ctx_t ctx;
  363. if ( copy_from_user( &ctx, (drm_ctx_t *)arg, sizeof(ctx) ) )
  364. return -EFAULT;
  366. DRM_DEBUG( "%dn", ctx.handle );
  367. return DRM(context_switch)( dev, dev->last_context, ctx.handle );
  368. }
  370. int DRM(newctx)( struct inode *inode, struct file *filp,
  371.  unsigned int cmd, unsigned long arg )
  372. {
  373. drm_file_t *priv = filp->private_data;
  374. drm_device_t *dev = priv->dev;
  375. drm_ctx_t ctx;
  377. if ( copy_from_user( &ctx, (drm_ctx_t *)arg, sizeof(ctx) ) )
  378. return -EFAULT;
  380. DRM_DEBUG( "%dn", ctx.handle );
  381. DRM(context_switch_complete)( dev, ctx.handle );
  383. return 0;
  384. }
  386. int DRM(rmctx)( struct inode *inode, struct file *filp,
  387. unsigned int cmd, unsigned long arg )
  388. {
  389. drm_file_t *priv = filp->private_data;
  390. drm_device_t *dev = priv->dev;
  391. drm_ctx_t ctx;
  393. if ( copy_from_user( &ctx, (drm_ctx_t *)arg, sizeof(ctx) ) )
  394. return -EFAULT;
  396. DRM_DEBUG( "%dn", ctx.handle );
  397. if ( ctx.handle == DRM_KERNEL_CONTEXT + 1 ) {
  398. priv->remove_auth_on_close = 1;
  399. }
  400. if ( ctx.handle != DRM_KERNEL_CONTEXT ) {
  401. #ifdef DRIVER_CTX_DTOR
  402. DRIVER_CTX_DTOR(ctx.handle); /* XXX: also pass dev ? */
  403. #endif
  404. DRM(ctxbitmap_free)( dev, ctx.handle );
  405. }
  407. return 0;
  408. }
  411. #else /* __HAVE_CTX_BITMAP */
  413. /* ================================================================
  414.  * Old-style context support
  415.  */
  418. int DRM(context_switch)(drm_device_t *dev, int old, int new)
  419. {
  420. char     buf[64];
  421. drm_queue_t *q;
  423. #if 0
  424. atomic_inc(&dev->total_ctx);
  425. #endif
  427. if (test_and_set_bit(0, &dev->context_flag)) {
  428. DRM_ERROR("Reentering -- FIXMEn");
  429. return -EBUSY;
  430. }
  432. #if __HAVE_DMA_HISTOGRAM
  433. dev->ctx_start = get_cycles();
  434. #endif
  436. DRM_DEBUG("Context switch from %d to %dn", old, new);
  438. if (new >= dev->queue_count) {
  439. clear_bit(0, &dev->context_flag);
  440. return -EINVAL;
  441. }
  443. if (new == dev->last_context) {
  444. clear_bit(0, &dev->context_flag);
  445. return 0;
  446. }
  448. q = dev->queuelist[new];
  449. atomic_inc(&q->use_count);
  450. if (atomic_read(&q->use_count) == 1) {
  451. atomic_dec(&q->use_count);
  452. clear_bit(0, &dev->context_flag);
  453. return -EINVAL;
  454. }
  456. if (DRM(flags) & DRM_FLAG_NOCTX) {
  457. DRM(context_switch_complete)(dev, new);
  458. } else {
  459. sprintf(buf, "C %d %dn", old, new);
  460. DRM(write_string)(dev, buf);
  461. }
  463. atomic_dec(&q->use_count);
  465. return 0;
  466. }
  468. int DRM(context_switch_complete)(drm_device_t *dev, int new)
  469. {
  470. drm_device_dma_t *dma = dev->dma;
  472. dev->last_context = new;  /* PRE/POST: This is the _only_ writer. */
  473. dev->last_switch  = jiffies;
  475. if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
  476. DRM_ERROR("Lock isn't held after context switchn");
  477. }
  479. if (!dma || !(dma->next_buffer && dma->next_buffer->while_locked)) {
  480. if (DRM(lock_free)(dev, &dev->lock.hw_lock->lock,
  481.   DRM_KERNEL_CONTEXT)) {
  482. DRM_ERROR("Cannot free lockn");
  483. }
  484. }
  486. #if __HAVE_DMA_HISTOGRAM
  487. atomic_inc(&dev->histo.ctx[DRM(histogram_slot)(get_cycles()
  488.       - dev->ctx_start)]);
  490. #endif
  491. clear_bit(0, &dev->context_flag);
  492. wake_up_interruptible(&dev->context_wait);
  494. return 0;
  495. }
  497. static int DRM(init_queue)(drm_device_t *dev, drm_queue_t *q, drm_ctx_t *ctx)
  498. {
  499. DRM_DEBUG("n");
  501. if (atomic_read(&q->use_count) != 1
  502.     || atomic_read(&q->finalization)
  503.     || atomic_read(&q->block_count)) {
  504. DRM_ERROR("New queue is already in use: u%d f%d b%dn",
  505.   atomic_read(&q->use_count),
  506.   atomic_read(&q->finalization),
  507.   atomic_read(&q->block_count));
  508. }
  510. atomic_set(&q->finalization,  0);
  511. atomic_set(&q->block_count,   0);
  512. atomic_set(&q->block_read,    0);
  513. atomic_set(&q->block_write,   0);
  514. atomic_set(&q->total_queued,  0);
  515. atomic_set(&q->total_flushed, 0);
  516. atomic_set(&q->total_locks,   0);
  518. init_waitqueue_head(&q->write_queue);
  519. init_waitqueue_head(&q->read_queue);
  520. init_waitqueue_head(&q->flush_queue);
  522. q->flags = ctx->flags;
  524. DRM(waitlist_create)(&q->waitlist, dev->dma->buf_count);
  526. return 0;
  527. }
  530. /* drm_alloc_queue:
  531. PRE: 1) dev->queuelist[0..dev->queue_count] is allocated and will not
  532. disappear (so all deallocation must be done after IOCTLs are off)
  533.      2) dev->queue_count < dev->queue_slots
  534.      3) dev->queuelist[i].use_count == 0 and
  535. dev->queuelist[i].finalization == 0 if i not in use
  536. POST: 1) dev->queuelist[i].use_count == 1
  537.       2) dev->queue_count < dev->queue_slots */
  539. static int DRM(alloc_queue)(drm_device_t *dev)
  540. {
  541. int     i;
  542. drm_queue_t *queue;
  543. int     oldslots;
  544. int     newslots;
  545. /* Check for a free queue */
  546. for (i = 0; i < dev->queue_count; i++) {
  547. atomic_inc(&dev->queuelist[i]->use_count);
  548. if (atomic_read(&dev->queuelist[i]->use_count) == 1
  549.     && !atomic_read(&dev->queuelist[i]->finalization)) {
  550. DRM_DEBUG("%d (free)n", i);
  551. return i;
  552. }
  553. atomic_dec(&dev->queuelist[i]->use_count);
  554. }
  555. /* Allocate a new queue */
  556. down(&dev->struct_sem);
  558. queue = gamma_alloc(sizeof(*queue), DRM_MEM_QUEUES);
  559. memset(queue, 0, sizeof(*queue));
  560. atomic_set(&queue->use_count, 1);
  562. ++dev->queue_count;
  563. if (dev->queue_count >= dev->queue_slots) {
  564. oldslots = dev->queue_slots * sizeof(*dev->queuelist);
  565. if (!dev->queue_slots) dev->queue_slots = 1;
  566. dev->queue_slots *= 2;
  567. newslots = dev->queue_slots * sizeof(*dev->queuelist);
  569. dev->queuelist = DRM(realloc)(dev->queuelist,
  570.       oldslots,
  571.       newslots,
  572.       DRM_MEM_QUEUES);
  573. if (!dev->queuelist) {
  574. up(&dev->struct_sem);
  575. DRM_DEBUG("out of memoryn");
  576. return -ENOMEM;
  577. }
  578. }
  579. dev->queuelist[dev->queue_count-1] = queue;
  581. up(&dev->struct_sem);
  582. DRM_DEBUG("%d (new)n", dev->queue_count - 1);
  583. return dev->queue_count - 1;
  584. }
  586. int DRM(resctx)(struct inode *inode, struct file *filp,
  587. unsigned int cmd, unsigned long arg)
  588. {
  589. drm_ctx_res_t res;
  590. drm_ctx_t ctx;
  591. int i;
  593. DRM_DEBUG("%dn", DRM_RESERVED_CONTEXTS);
  594. if (copy_from_user(&res, (drm_ctx_res_t *)arg, sizeof(res)))
  595. return -EFAULT;
  596. if (res.count >= DRM_RESERVED_CONTEXTS) {
  597. memset(&ctx, 0, sizeof(ctx));
  598. for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
  599. ctx.handle = i;
  600. if (copy_to_user(&res.contexts[i],
  601.  &i,
  602.  sizeof(i)))
  603. return -EFAULT;
  604. }
  605. }
  606. res.count = DRM_RESERVED_CONTEXTS;
  607. if (copy_to_user((drm_ctx_res_t *)arg, &res, sizeof(res)))
  608. return -EFAULT;
  609. return 0;
  610. }
  612. int DRM(addctx)(struct inode *inode, struct file *filp,
  613. unsigned int cmd, unsigned long arg)
  614. {
  615. drm_file_t *priv = filp->private_data;
  616. drm_device_t *dev = priv->dev;
  617. drm_ctx_t ctx;
  619. if (copy_from_user(&ctx, (drm_ctx_t *)arg, sizeof(ctx)))
  620. return -EFAULT;
  621. if ((ctx.handle = DRM(alloc_queue)(dev)) == DRM_KERNEL_CONTEXT) {
  622. /* Init kernel's context and get a new one. */
  623. DRM(init_queue)(dev, dev->queuelist[ctx.handle], &ctx);
  624. ctx.handle = DRM(alloc_queue)(dev);
  625. }
  626. DRM(init_queue)(dev, dev->queuelist[ctx.handle], &ctx);
  627. DRM_DEBUG("%dn", ctx.handle);
  628. if (copy_to_user((drm_ctx_t *)arg, &ctx, sizeof(ctx)))
  629. return -EFAULT;
  630. return 0;
  631. }
  633. int DRM(modctx)(struct inode *inode, struct file *filp,
  634. unsigned int cmd, unsigned long arg)
  635. {
  636. drm_file_t *priv = filp->private_data;
  637. drm_device_t *dev = priv->dev;
  638. drm_ctx_t ctx;
  639. drm_queue_t *q;
  641. if (copy_from_user(&ctx, (drm_ctx_t *)arg, sizeof(ctx)))
  642. return -EFAULT;
  644. DRM_DEBUG("%dn", ctx.handle);
  646. if (ctx.handle < 0 || ctx.handle >= dev->queue_count) return -EINVAL;
  647. q = dev->queuelist[ctx.handle];
  649. atomic_inc(&q->use_count);
  650. if (atomic_read(&q->use_count) == 1) {
  651. /* No longer in use */
  652. atomic_dec(&q->use_count);
  653. return -EINVAL;
  654. }
  656. if (DRM_BUFCOUNT(&q->waitlist)) {
  657. atomic_dec(&q->use_count);
  658. return -EBUSY;
  659. }
  661. q->flags = ctx.flags;
  663. atomic_dec(&q->use_count);
  664. return 0;
  665. }
  667. int DRM(getctx)(struct inode *inode, struct file *filp,
  668. unsigned int cmd, unsigned long arg)
  669. {
  670. drm_file_t *priv = filp->private_data;
  671. drm_device_t *dev = priv->dev;
  672. drm_ctx_t ctx;
  673. drm_queue_t *q;
  675. if (copy_from_user(&ctx, (drm_ctx_t *)arg, sizeof(ctx)))
  676. return -EFAULT;
  678. DRM_DEBUG("%dn", ctx.handle);
  680. if (ctx.handle >= dev->queue_count) return -EINVAL;
  681. q = dev->queuelist[ctx.handle];
  683. atomic_inc(&q->use_count);
  684. if (atomic_read(&q->use_count) == 1) {
  685. /* No longer in use */
  686. atomic_dec(&q->use_count);
  687. return -EINVAL;
  688. }
  690. ctx.flags = q->flags;
  691. atomic_dec(&q->use_count);
  693. if (copy_to_user((drm_ctx_t *)arg, &ctx, sizeof(ctx)))
  694. return -EFAULT;
  696. return 0;
  697. }
  699. int DRM(switchctx)(struct inode *inode, struct file *filp,
  700.    unsigned int cmd, unsigned long arg)
  701. {
  702. drm_file_t *priv = filp->private_data;
  703. drm_device_t *dev = priv->dev;
  704. drm_ctx_t ctx;
  706. if (copy_from_user(&ctx, (drm_ctx_t *)arg, sizeof(ctx)))
  707. return -EFAULT;
  708. DRM_DEBUG("%dn", ctx.handle);
  709. return DRM(context_switch)(dev, dev->last_context, ctx.handle);
  710. }
  712. int DRM(newctx)(struct inode *inode, struct file *filp,
  713. unsigned int cmd, unsigned long arg)
  714. {
  715. drm_file_t *priv = filp->private_data;
  716. drm_device_t *dev = priv->dev;
  717. drm_ctx_t ctx;
  719. if (copy_from_user(&ctx, (drm_ctx_t *)arg, sizeof(ctx)))
  720. return -EFAULT;
  721. DRM_DEBUG("%dn", ctx.handle);
  722. DRM(context_switch_complete)(dev, ctx.handle);
  724. return 0;
  725. }
  727. int DRM(rmctx)(struct inode *inode, struct file *filp,
  728.        unsigned int cmd, unsigned long arg)
  729. {
  730. drm_file_t *priv = filp->private_data;
  731. drm_device_t *dev = priv->dev;
  732. drm_ctx_t ctx;
  733. drm_queue_t *q;
  734. drm_buf_t *buf;
  736. if (copy_from_user(&ctx, (drm_ctx_t *)arg, sizeof(ctx)))
  737. return -EFAULT;
  738. DRM_DEBUG("%dn", ctx.handle);
  740. if (ctx.handle >= dev->queue_count) return -EINVAL;
  741. q = dev->queuelist[ctx.handle];
  743. atomic_inc(&q->use_count);
  744. if (atomic_read(&q->use_count) == 1) {
  745. /* No longer in use */
  746. atomic_dec(&q->use_count);
  747. return -EINVAL;
  748. }
  750. atomic_inc(&q->finalization); /* Mark queue in finalization state */
  751. atomic_sub(2, &q->use_count); /* Mark queue as unused (pending
  752.  finalization) */
  754. while (test_and_set_bit(0, &dev->interrupt_flag)) {
  755. schedule();
  756. if (signal_pending(current)) {
  757. clear_bit(0, &dev->interrupt_flag);
  758. return -EINTR;
  759. }
  760. }
  761. /* Remove queued buffers */
  762. while ((buf = DRM(waitlist_get)(&q->waitlist))) {
  763. DRM(free_buffer)(dev, buf);
  764. }
  765. clear_bit(0, &dev->interrupt_flag);
  767. /* Wakeup blocked processes */
  768. wake_up_interruptible(&q->read_queue);
  769. wake_up_interruptible(&q->write_queue);
  770. wake_up_interruptible(&q->flush_queue);
  772. /* Finalization over.  Queue is made
  773.    available when both use_count and
  774.    finalization become 0, which won't
  775.    happen until all the waiting processes
  776.    stop waiting. */
  777. atomic_dec(&q->finalization);
  778. return 0;
  779. }
  781. #endif /* __HAVE_CTX_BITMAP */