linux-core/drm_agpsupport.c

   1 /* drm_agpsupport.h -- DRM support for AGP/GART backend -*- linux-c -*-
   2  * Created: Mon Dec 13 09:56:45 1999 by faith@precisioninsight.com
   3  *
   4  * Copyright 1999 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  * Author:
  28  *    Rickard E. (Rik) Faith <faith@valinux.com>
  29  *    Gareth Hughes <gareth@valinux.com>
  30  */
  31
  32 #define __NO_VERSION__
  33 #include "drmP.h"
  34 #include <linux/module.h>
  35
  36 #if __REALLY_HAVE_AGP
  37
  38 #define DRM_AGP_GET (drm_agp_t *)inter_module_get("drm_agp")
  39 #define DRM_AGP_PUT inter_module_put("drm_agp")
  40
  41 static const drm_agp_t *drm_agp = NULL;
  42
  43 int DRM(agp_info)(struct inode *inode, struct file *filp,
  44                   unsigned int cmd, unsigned long arg)
  45 {
  46         drm_file_t       *priv   = filp->private_data;
  47         drm_device_t     *dev    = priv->dev;
  48         agp_kern_info    *kern;
  49         drm_agp_info_t   info;
  50
  51         if (!dev->agp || !dev->agp->acquired || !drm_agp->copy_info)
  52                 return -EINVAL;
  53
  54         kern                   = &dev->agp->agp_info;
  55         info.agp_version_major = kern->version.major;
  56         info.agp_version_minor = kern->version.minor;
  57         info.mode              = kern->mode;
  58         info.aperture_base     = kern->aper_base;
  59         info.aperture_size     = kern->aper_size * 1024 * 1024;
  60         info.memory_allowed    = kern->max_memory << PAGE_SHIFT;
  61         info.memory_used       = kern->current_memory << PAGE_SHIFT;
  62         info.id_vendor         = kern->device->vendor;
  63         info.id_device         = kern->device->device;
  64
  65         if (copy_to_user((drm_agp_info_t *)arg, &info, sizeof(info)))
  66                 return -EFAULT;
  67         return 0;
  68 }
  69
  70 int DRM(agp_acquire)(struct inode *inode, struct file *filp,
  71                      unsigned int cmd, unsigned long arg)
  72 {
  73         drm_file_t       *priv   = filp->private_data;
  74         drm_device_t     *dev    = priv->dev;
  75         int              retcode;
  76
  77         if (!dev->agp || dev->agp->acquired || !drm_agp->acquire)
  78                 return -EINVAL;
  79         if ((retcode = drm_agp->acquire())) return retcode;
  80         dev->agp->acquired = 1;
  81         return 0;
  82 }
  83
  84 int DRM(agp_release)(struct inode *inode, struct file *filp,
  85                      unsigned int cmd, unsigned long arg)
  86 {
  87         drm_file_t       *priv   = filp->private_data;
  88         drm_device_t     *dev    = priv->dev;
  89
  90         if (!dev->agp || !dev->agp->acquired || !drm_agp->release)
  91                 return -EINVAL;
  92         drm_agp->release();
  93         dev->agp->acquired = 0;
  94         return 0;
  95
  96 }
  97
  98 void DRM(agp_do_release)(void)
  99 {
 100         if (drm_agp->release) drm_agp->release();
 101 }
 102
 103 int DRM(agp_enable)(struct inode *inode, struct file *filp,
 104                     unsigned int cmd, unsigned long arg)
 105 {
 106         drm_file_t       *priv   = filp->private_data;
 107         drm_device_t     *dev    = priv->dev;
 108         drm_agp_mode_t   mode;
 109
 110         if (!dev->agp || !dev->agp->acquired || !drm_agp->enable)
 111                 return -EINVAL;
 112
 113         if (copy_from_user(&mode, (drm_agp_mode_t *)arg, sizeof(mode)))
 114                 return -EFAULT;
 115
 116         dev->agp->mode    = mode.mode;
 117         drm_agp->enable(mode.mode);
 118         dev->agp->base    = dev->agp->agp_info.aper_base;
 119         dev->agp->enabled = 1;
 120         return 0;
 121 }
 122
 123 int DRM(agp_alloc)(struct inode *inode, struct file *filp,
 124                    unsigned int cmd, unsigned long arg)
 125 {
 126         drm_file_t       *priv   = filp->private_data;
 127         drm_device_t     *dev    = priv->dev;
 128         drm_agp_buffer_t request;
 129         drm_agp_mem_t    *entry;
 130         agp_memory       *memory;
 131         unsigned long    pages;
 132         u32              type;
 133
 134         if (!dev->agp || !dev->agp->acquired) return -EINVAL;
 135         if (copy_from_user(&request, (drm_agp_buffer_t *)arg, sizeof(request)))
 136                 return -EFAULT;
 137         if (!(entry = DRM(alloc)(sizeof(*entry), DRM_MEM_AGPLISTS)))
 138                 return -ENOMEM;
 139
 140         memset(entry, 0, sizeof(*entry));
 141
 142         pages = (request.size + PAGE_SIZE - 1) / PAGE_SIZE;
 143         type = (u32) request.type;
 144
 145         if (!(memory = DRM(alloc_agp)(pages, type))) {
 146                 DRM(free)(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
 147                 return -ENOMEM;
 148         }
 149
 150         entry->handle    = (unsigned long)memory->key;
 151         entry->memory    = memory;
 152         entry->bound     = 0;
 153         entry->pages     = pages;
 154         entry->prev      = NULL;
 155         entry->next      = dev->agp->memory;
 156         if (dev->agp->memory) dev->agp->memory->prev = entry;
 157         dev->agp->memory = entry;
 158
 159         request.handle   = entry->handle;
 160         request.physical = memory->physical;
 161
 162         if (copy_to_user((drm_agp_buffer_t *)arg, &request, sizeof(request))) {
 163                 dev->agp->memory       = entry->next;
 164                 dev->agp->memory->prev = NULL;
 165                 DRM(free_agp)(memory, pages);
 166                 DRM(free)(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
 167                 return -EFAULT;
 168         }
 169         return 0;
 170 }
 171
 172 static drm_agp_mem_t *DRM(agp_lookup_entry)(drm_device_t *dev,
 173                                             unsigned long handle)
 174 {
 175         drm_agp_mem_t *entry;
 176
 177         for (entry = dev->agp->memory; entry; entry = entry->next) {
 178                 if (entry->handle == handle) return entry;
 179         }
 180         return NULL;
 181 }
 182
 183 int DRM(agp_unbind)(struct inode *inode, struct file *filp,
 184                     unsigned int cmd, unsigned long arg)
 185 {
 186         drm_file_t        *priv  = filp->private_data;
 187         drm_device_t      *dev   = priv->dev;
 188         drm_agp_binding_t request;
 189         drm_agp_mem_t     *entry;
 190         int ret;
 191
 192         if (!dev->agp || !dev->agp->acquired) return -EINVAL;
 193         if (copy_from_user(&request, (drm_agp_binding_t *)arg, sizeof(request)))
 194                 return -EFAULT;
 195         if (!(entry = DRM(agp_lookup_entry)(dev, request.handle)))
 196                 return -EINVAL;
 197         if (!entry->bound) return -EINVAL;
 198         ret = DRM(unbind_agp)(entry->memory);
 199         if (ret == 0)
 200             entry->bound = 0;
 201         return ret;
 202 }
 203
 204 int DRM(agp_bind)(struct inode *inode, struct file *filp,
 205                   unsigned int cmd, unsigned long arg)
 206 {
 207         drm_file_t        *priv  = filp->private_data;
 208         drm_device_t      *dev   = priv->dev;
 209         drm_agp_binding_t request;
 210         drm_agp_mem_t     *entry;
 211         int               retcode;
 212         int               page;
 213
 214         if (!dev->agp || !dev->agp->acquired || !drm_agp->bind_memory)
 215                 return -EINVAL;
 216         if (copy_from_user(&request, (drm_agp_binding_t *)arg, sizeof(request)))
 217                 return -EFAULT;
 218         if (!(entry = DRM(agp_lookup_entry)(dev, request.handle)))
 219                 return -EINVAL;
 220         if (entry->bound) return -EINVAL;
 221         page = (request.offset + PAGE_SIZE - 1) / PAGE_SIZE;
 222         if ((retcode = DRM(bind_agp)(entry->memory, page))) return retcode;
 223         entry->bound = dev->agp->base + (page << PAGE_SHIFT);
 224         DRM_DEBUG("base = 0x%lx entry->bound = 0x%lx\n",
 225                   dev->agp->base, entry->bound);
 226         return 0;
 227 }
 228
 229 int DRM(agp_free)(struct inode *inode, struct file *filp,
 230                   unsigned int cmd, unsigned long arg)
 231 {
 232         drm_file_t       *priv   = filp->private_data;
 233         drm_device_t     *dev    = priv->dev;
 234         drm_agp_buffer_t request;
 235         drm_agp_mem_t    *entry;
 236
 237         if (!dev->agp || !dev->agp->acquired) return -EINVAL;
 238         if (copy_from_user(&request, (drm_agp_buffer_t *)arg, sizeof(request)))
 239                 return -EFAULT;
 240         if (!(entry = DRM(agp_lookup_entry)(dev, request.handle)))
 241                 return -EINVAL;
 242         if (entry->bound) DRM(unbind_agp)(entry->memory);
 243
 244         if (entry->prev) entry->prev->next = entry->next;
 245         else             dev->agp->memory  = entry->next;
 246         if (entry->next) entry->next->prev = entry->prev;
 247         DRM(free_agp)(entry->memory, entry->pages);
 248         DRM(free)(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
 249         return 0;
 250 }
 251
 252 drm_agp_head_t *DRM(agp_init)(void)
 253 {
 254         drm_agp_head_t *head         = NULL;
 255
 256         drm_agp = DRM_AGP_GET;
 257         if (drm_agp) {
 258                 if (!(head = DRM(alloc)(sizeof(*head), DRM_MEM_AGPLISTS)))
 259                         return NULL;
 260                 memset((void *)head, 0, sizeof(*head));
 261                 drm_agp->copy_info(&head->agp_info);
 262                 if (head->agp_info.chipset == NOT_SUPPORTED) {
 263                         DRM(free)(head, sizeof(*head), DRM_MEM_AGPLISTS);
 264                         return NULL;
 265                 }
 266                 head->memory = NULL;
 267 #if LINUX_VERSION_CODE <= 0x020408
 268                 head->cant_use_aperture = 0;
 269                 head->page_mask = ~(0xfff);
 270 #else
 271                 head->cant_use_aperture = head->agp_info.cant_use_aperture;
 272                 head->page_mask = head->agp_info.page_mask;
 273 #endif
 274
 275                 DRM_INFO("AGP %d.%d aperture @ 0x%08lx %ZuMB\n",
 276                          head->agp_info.version.major,
 277                          head->agp_info.version.minor,
 278                          head->agp_info.aper_base,
 279                          head->agp_info.aper_size);
 280         }
 281         return head;
 282 }
 283
 284 void DRM(agp_uninit)(void)
 285 {
 286         DRM_AGP_PUT;
 287         drm_agp = NULL;
 288 }
 289
 290 agp_memory *DRM(agp_allocate_memory)(size_t pages, u32 type)
 291 {
 292         if (!drm_agp->allocate_memory) return NULL;
 293         return drm_agp->allocate_memory(pages, type);
 294 }
 295
 296 int DRM(agp_free_memory)(agp_memory *handle)
 297 {
 298         if (!handle || !drm_agp->free_memory) return 0;
 299         drm_agp->free_memory(handle);
 300         return 1;
 301 }
 302
 303 int DRM(agp_bind_memory)(agp_memory *handle, off_t start)
 304 {
 305         if (!handle || !drm_agp->bind_memory) return -EINVAL;
 306         return drm_agp->bind_memory(handle, start);
 307 }
 308
 309 int DRM(agp_unbind_memory)(agp_memory *handle)
 310 {
 311         if (!handle || !drm_agp->unbind_memory) return -EINVAL;
 312         return drm_agp->unbind_memory(handle);
 313 }
 314
 315 #endif /* __REALLY_HAVE_AGP */