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