drivers/char/drm/fops.c

   1 /* fops.c -- File operations for DRM -*- linux-c -*-
   2  * Created: Mon Jan  4 08:58:31 1999 by faith@precisioninsight.com
   3  * Revised: Fri Aug 20 11:31:46 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: xc/programs/Xserver/hw/xfree86/os-support/linux/drm/generic/fops.c,v 1.3 1999/08/20 15:36:45 faith Exp $
  28  * $XFree86$
  29  *
  30  */
  31
  32 #define __NO_VERSION__
  33 #include "drmP.h"
  34
  35 /* drm_open is called whenever a process opens /dev/drm. */
  36
  37 int drm_open_helper(struct inode *inode, struct file *filp, drm_device_t *dev)
  38 {
  39         kdev_t       minor = MINOR(inode->i_rdev);
  40         drm_file_t   *priv;
  41
  42         if (filp->f_flags & O_EXCL)   return -EBUSY; /* No exclusive opens */
  43
  44         DRM_DEBUG("pid = %d, minor = %d\n", current->pid, minor);
  45
  46         priv                = drm_alloc(sizeof(*priv), DRM_MEM_FILES);
  47         memset(priv, 0, sizeof(*priv));
  48         filp->private_data  = priv;
  49         priv->uid           = current->euid;
  50         priv->pid           = current->pid;
  51         priv->minor         = minor;
  52         priv->dev           = dev;
  53         priv->ioctl_count   = 0;
  54         priv->authenticated = capable(CAP_SYS_ADMIN);
  55
  56         down(&dev->struct_sem);
  57         if (!dev->file_last) {
  58                 priv->next      = NULL;
  59                 priv->prev      = NULL;
  60                 dev->file_first = priv;
  61                 dev->file_last  = priv;
  62         } else {
  63                 priv->next           = NULL;
  64                 priv->prev           = dev->file_last;
  65                 dev->file_last->next = priv;
  66                 dev->file_last       = priv;
  67         }
  68         up(&dev->struct_sem);
  69
  70         return 0;
  71 }
  72
  73 int drm_flush(struct file *filp)
  74 {
  75         drm_file_t    *priv   = filp->private_data;
  76         drm_device_t  *dev    = priv->dev;
  77
  78         DRM_DEBUG("pid = %d, device = 0x%x, open_count = %d, f_count = %d\n",
  79                   current->pid, dev->device, dev->open_count, filp->f_count);
  80         return 0;
  81 }
  82
  83 /* drm_release is called whenever a process closes /dev/drm*.  Linux calls
  84    this only if any mappings have been closed. */
  85
  86 int drm_release(struct inode *inode, struct file *filp)
  87 {
  88         drm_file_t    *priv   = filp->private_data;
  89         drm_device_t  *dev    = priv->dev;
  90
  91         DRM_DEBUG("pid = %d, device = 0x%x, open_count = %d\n",
  92                   current->pid, dev->device, dev->open_count);
  93
  94         drm_reclaim_buffers(dev, priv->pid);
  95
  96         drm_fasync(-1, filp, 0);
  97
  98         down(&dev->struct_sem);
  99         if (priv->prev) priv->prev->next = priv->next;
 100         else            dev->file_first  = priv->next;
 101         if (priv->next) priv->next->prev = priv->prev;
 102         else            dev->file_last   = priv->prev;
 103         up(&dev->struct_sem);
 104
 105         drm_free(priv, sizeof(*priv), DRM_MEM_FILES);
 106
 107         return 0;
 108 }
 109
 110 int drm_fasync(int fd, struct file *filp, int on)
 111 {
 112         drm_file_t    *priv   = filp->private_data;
 113         drm_device_t  *dev    = priv->dev;
 114         int           retcode;
 115
 116         DRM_DEBUG("fd = %d, device = 0x%x\n", fd, dev->device);
 117         retcode = fasync_helper(fd, filp, on, &dev->buf_async);
 118         if (retcode < 0) return retcode;
 119         return 0;
 120 }
 121
 122
 123 /* The drm_read and drm_write_string code (especially that which manages
 124    the circular buffer), is based on Alessandro Rubini's LINUX DEVICE
 125    DRIVERS (Cambridge: O'Reilly, 1998), pages 111-113. */
 126
 127 ssize_t drm_read(struct file *filp, char *buf, size_t count, loff_t *off)
 128 {
 129         drm_file_t    *priv   = filp->private_data;
 130         drm_device_t  *dev    = priv->dev;
 131         int           left;
 132         int           avail;
 133         int           send;
 134         int           cur;
 135
 136         DRM_DEBUG("%p, %p\n", dev->buf_rp, dev->buf_wp);
 137
 138         while (dev->buf_rp == dev->buf_wp) {
 139                 DRM_DEBUG("  sleeping\n");
 140                 if (filp->f_flags & O_NONBLOCK) {
 141                         return -EAGAIN;
 142                 }
 143                 interruptible_sleep_on(&dev->buf_readers);
 144                 if (signal_pending(current)) {
 145                         DRM_DEBUG("  interrupted\n");
 146                         return -ERESTARTSYS;
 147                 }
 148                 DRM_DEBUG("  awake\n");
 149         }
 150
 151         left  = (dev->buf_rp + DRM_BSZ - dev->buf_wp) % DRM_BSZ;
 152         avail = DRM_BSZ - left;
 153         send  = DRM_MIN(avail, count);
 154
 155         while (send) {
 156                 if (dev->buf_wp > dev->buf_rp) {
 157                         cur = DRM_MIN(send, dev->buf_wp - dev->buf_rp);
 158                 } else {
 159                         cur = DRM_MIN(send, dev->buf_end - dev->buf_rp);
 160                 }
 161                 copy_to_user_ret(buf, dev->buf_rp, cur, -EINVAL);
 162                 dev->buf_rp += cur;
 163                 if (dev->buf_rp == dev->buf_end) dev->buf_rp = dev->buf;
 164                 send -= cur;
 165         }
 166
 167         wake_up_interruptible(&dev->buf_writers);
 168         return DRM_MIN(avail, count);;
 169 }
 170
 171 int drm_write_string(drm_device_t *dev, const char *s)
 172 {
 173         int left   = (dev->buf_rp + DRM_BSZ - dev->buf_wp) % DRM_BSZ;
 174         int send   = strlen(s);
 175         int count;
 176
 177         DRM_DEBUG("%d left, %d to send (%p, %p)\n",
 178                   left, send, dev->buf_rp, dev->buf_wp);
 179
 180         if (left == 1 || dev->buf_wp != dev->buf_rp) {
 181                 DRM_ERROR("Buffer not empty (%d left, wp = %p, rp = %p)\n",
 182                           left,
 183                           dev->buf_wp,
 184                           dev->buf_rp);
 185         }
 186
 187         while (send) {
 188                 if (dev->buf_wp >= dev->buf_rp) {
 189                         count = DRM_MIN(send, dev->buf_end - dev->buf_wp);
 190                         if (count == left) --count; /* Leave a hole */
 191                 } else {
 192                         count = DRM_MIN(send, dev->buf_rp - dev->buf_wp - 1);
 193                 }
 194                 strncpy(dev->buf_wp, s, count);
 195                 dev->buf_wp += count;
 196                 if (dev->buf_wp == dev->buf_end) dev->buf_wp = dev->buf;
 197                 send -= count;
 198         }
 199
 200         if (dev->buf_async) kill_fasync(dev->buf_async, SIGIO);
 201         DRM_DEBUG("waking\n");
 202         wake_up_interruptible(&dev->buf_readers);
 203         return 0;
 204 }