linux/tdfx_context.c

   1 /* tdfx_context.c -- IOCTLs for tdfx contexts -*- linux-c -*-
   2  * Created: Thu Oct  7 10:50:22 1999 by faith@precisioninsight.com
   3  * Revised: Sat Oct  9 23:39:56 1999 by faith@precisioninsight.com
   4  *
   5  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
   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  * PRECISION INSIGHT 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 OTHER
  25  * DEALINGS IN THE SOFTWARE.
  26  *
  27  * $PI$
  28  * $XFree86$
  29  *
  30  */
  31
  32 #include <linux/sched.h>
  33
  34 #define __NO_VERSION__
  35 #include "drmP.h"
  36 #include "tdfx_drv.h"
  37
  38 extern drm_ctx_t tdfx_res_ctx;
  39
  40 static int tdfx_alloc_queue(drm_device_t *dev)
  41 {
  42         static int context = 0;
  43
  44         return ++context;       /* Should this reuse contexts in the future? */
  45 }
  46
  47 int tdfx_context_switch(drm_device_t *dev, int old, int new)
  48 {
  49         char        buf[64];
  50
  51         atomic_inc(&dev->total_ctx);
  52
  53         if (test_and_set_bit(0, &dev->context_flag)) {
  54                 DRM_ERROR("Reentering -- FIXME\n");
  55                 return -EBUSY;
  56         }
  57
  58 #if DRM_DMA_HISTOGRAM
  59         dev->ctx_start = get_cycles();
  60 #endif
  61
  62         DRM_DEBUG("Context switch from %d to %d\n", old, new);
  63
  64         if (new == dev->last_context) {
  65                 clear_bit(0, &dev->context_flag);
  66                 return 0;
  67         }
  68
  69         if (drm_flags & DRM_FLAG_NOCTX) {
  70                 tdfx_context_switch_complete(dev, new);
  71         } else {
  72                 sprintf(buf, "C %d %d\n", old, new);
  73                 drm_write_string(dev, buf);
  74         }
  75
  76         return 0;
  77 }
  78
  79 int tdfx_context_switch_complete(drm_device_t *dev, int new)
  80 {
  81         dev->last_context = new;  /* PRE/POST: This is the _only_ writer. */
  82         dev->last_switch  = jiffies;
  83
  84         if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
  85                 DRM_ERROR("Lock isn't held after context switch\n");
  86         }
  87
  88                                 /* If a context switch is ever initiated
  89                                    when the kernel holds the lock, release
  90                                    that lock here. */
  91 #if DRM_DMA_HISTOGRAM
  92         atomic_inc(&dev->histo.ctx[drm_histogram_slot(get_cycles()
  93                                                       - dev->ctx_start)]);
  94
  95 #endif
  96         clear_bit(0, &dev->context_flag);
  97         wake_up(&dev->context_wait);
  98
  99         return 0;
 100 }
 101
 102
 103 int tdfx_resctx(struct inode *inode, struct file *filp, unsigned int cmd,
 104                unsigned long arg)
 105 {
 106         drm_ctx_res_t   res;
 107         drm_ctx_t       ctx;
 108         int             i;
 109
 110         DRM_DEBUG("%d\n", DRM_RESERVED_CONTEXTS);
 111         copy_from_user_ret(&res, (drm_ctx_res_t *)arg, sizeof(res), -EFAULT);
 112         if (res.count >= DRM_RESERVED_CONTEXTS) {
 113                 memset(&ctx, 0, sizeof(ctx));
 114                 for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
 115                         ctx.handle = i;
 116                         copy_to_user_ret(&res.contexts[i],
 117                                          &i,
 118                                          sizeof(i),
 119                                          -EFAULT);
 120                 }
 121         }
 122         res.count = DRM_RESERVED_CONTEXTS;
 123         copy_to_user_ret((drm_ctx_res_t *)arg, &res, sizeof(res), -EFAULT);
 124         return 0;
 125 }
 126
 127
 128 int tdfx_addctx(struct inode *inode, struct file *filp, unsigned int cmd,
 129                unsigned long arg)
 130 {
 131         drm_file_t      *priv   = filp->private_data;
 132         drm_device_t    *dev    = priv->dev;
 133         drm_ctx_t       ctx;
 134
 135         copy_from_user_ret(&ctx, (drm_ctx_t *)arg, sizeof(ctx), -EFAULT);
 136         if ((ctx.handle = tdfx_alloc_queue(dev)) == DRM_KERNEL_CONTEXT) {
 137                                 /* Skip kernel's context and get a new one. */
 138                 ctx.handle = tdfx_alloc_queue(dev);
 139         }
 140         DRM_DEBUG("%d\n", ctx.handle);
 141         copy_to_user_ret((drm_ctx_t *)arg, &ctx, sizeof(ctx), -EFAULT);
 142         return 0;
 143 }
 144
 145 int tdfx_modctx(struct inode *inode, struct file *filp, unsigned int cmd,
 146         unsigned long arg)
 147 {
 148         drm_ctx_t ctx;
 149
 150         copy_from_user_ret(&ctx, (drm_ctx_t*)arg, sizeof(ctx), -EFAULT);
 151         if (ctx.flags==_DRM_CONTEXT_PRESERVED)
 152                 tdfx_res_ctx.handle=ctx.handle;
 153         return 0;
 154 }
 155
 156 int tdfx_getctx(struct inode *inode, struct file *filp, unsigned int cmd,
 157         unsigned long arg)
 158 {
 159         drm_ctx_t ctx;
 160
 161         copy_from_user_ret(&ctx, (drm_ctx_t*)arg, sizeof(ctx), -EFAULT);
 162         /* This is 0, because we don't hanlde any context flags */
 163         ctx.flags = 0;
 164         copy_to_user_ret((drm_ctx_t*)arg, &ctx, sizeof(ctx), -EFAULT);
 165         return 0;
 166 }
 167
 168 int tdfx_switchctx(struct inode *inode, struct file *filp, unsigned int cmd,
 169                    unsigned long arg)
 170 {
 171         drm_file_t      *priv   = filp->private_data;
 172         drm_device_t    *dev    = priv->dev;
 173         drm_ctx_t       ctx;
 174
 175         copy_from_user_ret(&ctx, (drm_ctx_t *)arg, sizeof(ctx), -EFAULT);
 176         DRM_DEBUG("%d\n", ctx.handle);
 177         return tdfx_context_switch(dev, dev->last_context, ctx.handle);
 178 }
 179
 180 int tdfx_newctx(struct inode *inode, struct file *filp, unsigned int cmd,
 181                 unsigned long arg)
 182 {
 183         drm_file_t      *priv   = filp->private_data;
 184         drm_device_t    *dev    = priv->dev;
 185         drm_ctx_t       ctx;
 186
 187         copy_from_user_ret(&ctx, (drm_ctx_t *)arg, sizeof(ctx), -EFAULT);
 188         DRM_DEBUG("%d\n", ctx.handle);
 189         tdfx_context_switch_complete(dev, ctx.handle);
 190
 191         return 0;
 192 }
 193
 194 int tdfx_rmctx(struct inode *inode, struct file *filp, unsigned int cmd,
 195                unsigned long arg)
 196 {
 197         drm_ctx_t       ctx;
 198
 199         copy_from_user_ret(&ctx, (drm_ctx_t *)arg, sizeof(ctx), -EFAULT);
 200         DRM_DEBUG("%d\n", ctx.handle);
 201                                 /* This is currently a noop because we
 202                                    don't reuse context values.  Perhaps we
 203                                    should? */
 204
 205         return 0;
 206 }