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->memory;
 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
 191         if (!dev->agp || !dev->agp->acquired) return -EINVAL;
 192         if (copy_from_user(&request, (drm_agp_binding_t *)arg, sizeof(request)))
 193                 return -EFAULT;
 194         if (!(entry = DRM(agp_lookup_entry)(dev, request.handle)))
 195                 return -EINVAL;
 196         if (!entry->bound) return -EINVAL;
 197         return DRM(unbind_agp)(entry->memory);
 198 }
 199
 200 int DRM(agp_bind)(struct inode *inode, struct file *filp,
 201                   unsigned int cmd, unsigned long arg)
 202 {
 203         drm_file_t        *priv  = filp->private_data;
 204         drm_device_t      *dev   = priv->dev;
 205         drm_agp_binding_t request;
 206         drm_agp_mem_t     *entry;
 207         int               retcode;
 208         int               page;
 209
 210         if (!dev->agp || !dev->agp->acquired || !drm_agp->bind_memory)
 211                 return -EINVAL;
 212         if (copy_from_user(&request, (drm_agp_binding_t *)arg, sizeof(request)))
 213                 return -EFAULT;
 214         if (!(entry = DRM(agp_lookup_entry)(dev, request.handle)))
 215                 return -EINVAL;
 216         if (entry->bound) return -EINVAL;
 217         page = (request.offset + PAGE_SIZE - 1) / PAGE_SIZE;
 218         if ((retcode = DRM(bind_agp)(entry->memory, page))) return retcode;
 219         entry->bound = dev->agp->base + (page << PAGE_SHIFT);
 220         DRM_DEBUG("base = 0x%lx entry->bound = 0x%lx\n",
 221                   dev->agp->base, entry->bound);
 222         return 0;
 223 }
 224
 225 int DRM(agp_free)(struct inode *inode, struct file *filp,
 226                   unsigned int cmd, unsigned long arg)
 227 {
 228         drm_file_t       *priv   = filp->private_data;
 229         drm_device_t     *dev    = priv->dev;
 230         drm_agp_buffer_t request;
 231         drm_agp_mem_t    *entry;
 232
 233         if (!dev->agp || !dev->agp->acquired) return -EINVAL;
 234         if (copy_from_user(&request, (drm_agp_buffer_t *)arg, sizeof(request)))
 235                 return -EFAULT;
 236         if (!(entry = DRM(agp_lookup_entry)(dev, request.handle)))
 237                 return -EINVAL;
 238         if (entry->bound) DRM(unbind_agp)(entry->memory);
 239
 240         if (entry->prev) entry->prev->next = entry->next;
 241         else             dev->agp->memory  = entry->next;
 242         if (entry->next) entry->next->prev = entry->prev;
 243         DRM(free_agp)(entry->memory, entry->pages);
 244         DRM(free)(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
 245         return 0;
 246 }
 247
 248 drm_agp_head_t *DRM(agp_init)(void)
 249 {
 250         drm_agp_head_t *head         = NULL;
 251
 252         drm_agp = DRM_AGP_GET;
 253         if (drm_agp) {
 254                 if (!(head = DRM(alloc)(sizeof(*head), DRM_MEM_AGPLISTS)))
 255                         return NULL;
 256                 memset((void *)head, 0, sizeof(*head));
 257                 drm_agp->copy_info(&head->agp_info);
 258                 if (head->agp_info.chipset == NOT_SUPPORTED) {
 259                         DRM(free)(head, sizeof(*head), DRM_MEM_AGPLISTS);
 260                         return NULL;
 261                 }
 262                 head->memory = NULL;
 263                 switch (head->agp_info.chipset) {
 264                 case INTEL_GENERIC:     head->chipset = "Intel";         break;
 265                 case INTEL_LX:          head->chipset = "Intel 440LX";   break;
 266                 case INTEL_BX:          head->chipset = "Intel 440BX";   break;
 267                 case INTEL_GX:          head->chipset = "Intel 440GX";   break;
 268                 case INTEL_I810:        head->chipset = "Intel i810";    break;
 269
 270                 case INTEL_I815:        head->chipset = "Intel i815";    break;
 271                 case INTEL_I840:        head->chipset = "Intel i840";    break;
 272                 case INTEL_I850:        head->chipset = "Intel i850";    break;
 273
 274                 case VIA_GENERIC:       head->chipset = "VIA";           break;
 275                 case VIA_VP3:           head->chipset = "VIA VP3";       break;
 276                 case VIA_MVP3:          head->chipset = "VIA MVP3";      break;
 277                 case VIA_MVP4:          head->chipset = "VIA MVP4";      break;
 278                 case VIA_APOLLO_KX133:  head->chipset = "VIA Apollo KX133";
 279                         break;
 280                 case VIA_APOLLO_KT133:  head->chipset = "VIA Apollo KT133";
 281                         break;
 282
 283                 case VIA_APOLLO_PRO:    head->chipset = "VIA Apollo Pro";
 284                         break;
 285                 case SIS_GENERIC:       head->chipset = "SiS";           break;
 286                 case AMD_GENERIC:       head->chipset = "AMD";           break;
 287                 case AMD_IRONGATE:      head->chipset = "AMD Irongate";  break;
 288                 case ALI_GENERIC:       head->chipset = "ALi";           break;
 289                 case ALI_M1541:         head->chipset = "ALi M1541";     break;
 290
 291 #if LINUX_VERSION_CODE >= 0x020402
 292                 case ALI_M1621:         head->chipset = "ALi M1621";     break;
 293                 case ALI_M1631:         head->chipset = "ALi M1631";     break;
 294                 case ALI_M1632:         head->chipset = "ALi M1632";     break;
 295                 case ALI_M1641:         head->chipset = "ALi M1641";     break;
 296                 case ALI_M1647:         head->chipset = "ALi M1647";     break;
 297                 case ALI_M1651:         head->chipset = "ALi M1651";     break;
 298 #endif
 299
 300 #if LINUX_VERSION_CODE >= 0x020406
 301                 case SVWRKS_HE:         head->chipset = "Serverworks HE";
 302                         break;
 303                 case SVWRKS_LE:         head->chipset = "Serverworks LE";
 304                         break;
 305                 case SVWRKS_GENERIC:    head->chipset = "Serverworks Generic";
 306                         break;
 307 #endif
 308
 309                 default:                head->chipset = "Unknown";       break;
 310                 }
 311                 DRM_INFO("AGP %d.%d on %s @ 0x%08lx %ZuMB\n",
 312                          head->agp_info.version.major,
 313                          head->agp_info.version.minor,
 314                          head->chipset,
 315                          head->agp_info.aper_base,
 316                          head->agp_info.aper_size);
 317         }
 318         return head;
 319 }
 320
 321 void DRM(agp_uninit)(void)
 322 {
 323         DRM_AGP_PUT;
 324         drm_agp = NULL;
 325 }
 326
 327 agp_memory *DRM(agp_allocate_memory)(size_t pages, u32 type)
 328 {
 329         if (!drm_agp->allocate_memory) return NULL;
 330         return drm_agp->allocate_memory(pages, type);
 331 }
 332
 333 int DRM(agp_free_memory)(agp_memory *handle)
 334 {
 335         if (!handle || !drm_agp->free_memory) return 0;
 336         drm_agp->free_memory(handle);
 337         return 1;
 338 }
 339
 340 int DRM(agp_bind_memory)(agp_memory *handle, off_t start)
 341 {
 342         if (!handle || !drm_agp->bind_memory) return -EINVAL;
 343         return drm_agp->bind_memory(handle, start);
 344 }
 345
 346 int DRM(agp_unbind_memory)(agp_memory *handle)
 347 {
 348         if (!handle || !drm_agp->unbind_memory) return -EINVAL;
 349         return drm_agp->unbind_memory(handle);
 350 }
 351
 352 #endif /* __REALLY_HAVE_AGP */