drivers/char/agp/backend.c

   1 /*
   2  * AGPGART driver backend routines.
   3  * Copyright (C) 2002-2003 Dave Jones.
   4  * Copyright (C) 1999 Jeff Hartmann.
   5  * Copyright (C) 1999 Precision Insight, Inc.
   6  * Copyright (C) 1999 Xi Graphics, Inc.
   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 shall be included
  16  * in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * JEFF HARTMANN, DAVE JONES, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM,
  22  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  23  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
  24  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  * TODO:
  27  * - Allocate more than order 0 pages to avoid too much linear map splitting.
  28  */
  29 #include <linux/config.h>
  30 #include <linux/module.h>
  31 #include <linux/pci.h>
  32 #include <linux/init.h>
  33 #include <linux/pagemap.h>
  34 #include <linux/miscdevice.h>
  35 #include <linux/pm.h>
  36 #include <linux/agp_backend.h>
  37 #include <linux/vmalloc.h>
  38 #include <asm/io.h>
  39 #include "agp.h"
  40
  41 /* Due to XFree86 brain-damage, we can't go to 1.0 until they
  42  * fix some real stupidity. It's only by chance we can bump
  43  * past 0.99 at all due to some boolean logic error. */
  44 #define AGPGART_VERSION_MAJOR 0
  45 #define AGPGART_VERSION_MINOR 100
  46 static struct agp_version agp_current_version =
  47 {
  48         .major = AGPGART_VERSION_MAJOR,
  49         .minor = AGPGART_VERSION_MINOR,
  50 };
  51
  52 static int agp_count=0;
  53
  54 struct agp_bridge_data agp_bridge_dummy = { .type = NOT_SUPPORTED };
  55 struct agp_bridge_data *agp_bridge = &agp_bridge_dummy;
  56 EXPORT_SYMBOL(agp_bridge);
  57
  58
  59 /**
  60  *      agp_backend_acquire  -  attempt to acquire the agp backend.
  61  *
  62  *      returns -EBUSY if agp is in use,
  63  *      returns 0 if the caller owns the agp backend
  64  */
  65 int agp_backend_acquire(void)
  66 {
  67         if (agp_bridge->type == NOT_SUPPORTED)
  68                 return -EINVAL;
  69         if (atomic_read(&agp_bridge->agp_in_use))
  70                 return -EBUSY;
  71         atomic_inc(&agp_bridge->agp_in_use);
  72         return 0;
  73 }
  74 EXPORT_SYMBOL(agp_backend_acquire);
  75
  76
  77 /**
  78  *      agp_backend_release  -  release the lock on the agp backend.
  79  *
  80  *      The caller must insure that the graphics aperture translation table
  81  *      is read for use by another entity.
  82  *
  83  *      (Ensure that all memory it bound is unbound.)
  84  */
  85 void agp_backend_release(void)
  86 {
  87         if (agp_bridge->type != NOT_SUPPORTED)
  88                 atomic_dec(&agp_bridge->agp_in_use);
  89 }
  90 EXPORT_SYMBOL(agp_backend_release);
  91
  92
  93 struct { int mem, agp; } maxes_table[] = {
  94         {0, 0},
  95         {32, 4},
  96         {64, 28},
  97         {128, 96},
  98         {256, 204},
  99         {512, 440},
 100         {1024, 942},
 101         {2048, 1920},
 102         {4096, 3932}
 103 };
 104
 105 static int agp_find_max(void)
 106 {
 107         long memory, index, result;
 108
 109         memory = (num_physpages << PAGE_SHIFT) >> 20;
 110         index = 1;
 111
 112         while ((memory > maxes_table[index].mem) && (index < 8))
 113                 index++;
 114
 115         result = maxes_table[index - 1].agp +
 116            ( (memory - maxes_table[index - 1].mem)  *
 117              (maxes_table[index].agp - maxes_table[index - 1].agp)) /
 118            (maxes_table[index].mem - maxes_table[index - 1].mem);
 119
 120         printk(KERN_INFO PFX "Maximum main memory to use for agp memory: %ldM\n", result);
 121         result = result << (20 - PAGE_SHIFT);
 122         return result;
 123 }
 124
 125
 126 static int agp_backend_initialize(struct agp_bridge_data *bridge)
 127 {
 128         int size_value, rc, got_gatt=0, got_keylist=0;
 129
 130         bridge->max_memory_agp = agp_find_max();
 131         bridge->version = &agp_current_version;
 132
 133         if (bridge->driver->needs_scratch_page) {
 134                 void *addr = bridge->driver->agp_alloc_page();
 135
 136                 if (!addr) {
 137                         printk(KERN_ERR PFX "unable to get memory for scratch page.\n");
 138                         return -ENOMEM;
 139                 }
 140
 141                 bridge->scratch_page_real = virt_to_phys(addr);
 142                 bridge->scratch_page =
 143                     bridge->driver->mask_memory(bridge->scratch_page_real, 0);
 144         }
 145
 146         size_value = bridge->driver->fetch_size();
 147         if (size_value == 0) {
 148                 printk(KERN_ERR PFX "unable to determine aperture size.\n");
 149                 rc = -EINVAL;
 150                 goto err_out;
 151         }
 152         if (bridge->driver->create_gatt_table()) {
 153                 printk(KERN_ERR PFX
 154                     "unable to get memory for graphics translation table.\n");
 155                 rc = -ENOMEM;
 156                 goto err_out;
 157         }
 158         got_gatt = 1;
 159
 160         bridge->key_list = vmalloc(PAGE_SIZE * 4);
 161         if (bridge->key_list == NULL) {
 162                 printk(KERN_ERR PFX "error allocating memory for key lists.\n");
 163                 rc = -ENOMEM;
 164                 goto err_out;
 165         }
 166         got_keylist = 1;
 167
 168         /* FIXME vmalloc'd memory not guaranteed contiguous */
 169         memset(bridge->key_list, 0, PAGE_SIZE * 4);
 170
 171         if (bridge->driver->configure()) {
 172                 printk(KERN_ERR PFX "error configuring host chipset.\n");
 173                 rc = -EINVAL;
 174                 goto err_out;
 175         }
 176
 177         printk(KERN_INFO PFX "AGP aperture is %dM @ 0x%lx\n",
 178                size_value, bridge->gart_bus_addr);
 179
 180         return 0;
 181
 182 err_out:
 183         if (bridge->driver->needs_scratch_page)
 184                 bridge->driver->agp_destroy_page(
 185                                 phys_to_virt(bridge->scratch_page_real));
 186         if (got_gatt)
 187                 bridge->driver->free_gatt_table();
 188         if (got_keylist) {
 189                 vfree(bridge->key_list);
 190                 bridge->key_list = NULL;
 191         }
 192         return rc;
 193 }
 194
 195 /* cannot be __exit b/c as it could be called from __init code */
 196 static void agp_backend_cleanup(struct agp_bridge_data *bridge)
 197 {
 198         if (bridge->driver->cleanup)
 199                 bridge->driver->cleanup();
 200         if (bridge->driver->free_gatt_table)
 201                 bridge->driver->free_gatt_table();
 202         if (bridge->key_list) {
 203                 vfree(bridge->key_list);
 204                 bridge->key_list = NULL;
 205         }
 206
 207         if (bridge->driver->agp_destroy_page &&
 208             bridge->driver->needs_scratch_page)
 209                 bridge->driver->agp_destroy_page(
 210                                 phys_to_virt(bridge->scratch_page_real));
 211 }
 212
 213 static const drm_agp_t drm_agp = {
 214         &agp_free_memory,
 215         &agp_allocate_memory,
 216         &agp_bind_memory,
 217         &agp_unbind_memory,
 218         &agp_enable,
 219         &agp_backend_acquire,
 220         &agp_backend_release,
 221         &agp_copy_info
 222 };
 223
 224 /* XXX Kludge alert: agpgart isn't ready for multiple bridges yet */
 225 struct agp_bridge_data *agp_alloc_bridge(void)
 226 {
 227         return agp_bridge;
 228 }
 229 EXPORT_SYMBOL(agp_alloc_bridge);
 230
 231
 232 void agp_put_bridge(struct agp_bridge_data *bridge)
 233 {
 234 }
 235 EXPORT_SYMBOL(agp_put_bridge);
 236
 237
 238 int agp_add_bridge(struct agp_bridge_data *bridge)
 239 {
 240         int error;
 241
 242         if (!bridge->dev) {
 243                 printk (KERN_DEBUG PFX "Erk, registering with no pci_dev!\n");
 244                 return -EINVAL;
 245         }
 246
 247         if (agp_count) {
 248                 printk (KERN_INFO PFX
 249                        "Only one agpgart device currently supported.\n");
 250                 return -ENODEV;
 251         }
 252
 253         /* Grab reference on the chipset driver. */
 254         if (!try_module_get(bridge->driver->owner)) {
 255                 printk (KERN_INFO PFX "Couldn't lock chipset driver.\n");
 256                 return -EINVAL;
 257         }
 258
 259         bridge->type = SUPPORTED;
 260
 261         error = agp_backend_initialize(agp_bridge);
 262         if (error) {
 263                 printk (KERN_INFO PFX "agp_backend_initialize() failed.\n");
 264                 goto err_out;
 265         }
 266
 267         error = agp_frontend_initialize();
 268         if (error) {
 269                 printk (KERN_INFO PFX "agp_frontend_initialize() failed.\n");
 270                 goto frontend_err;
 271         }
 272
 273         /* FIXME: What to do with this? */
 274         inter_module_register("drm_agp", THIS_MODULE, &drm_agp);
 275
 276         agp_count++;
 277         return 0;
 278
 279 frontend_err:
 280         agp_backend_cleanup(agp_bridge);
 281 err_out:
 282         bridge->type = NOT_SUPPORTED;
 283         module_put(bridge->driver->owner);
 284         return error;
 285 }
 286 EXPORT_SYMBOL_GPL(agp_add_bridge);
 287
 288
 289 void agp_remove_bridge(struct agp_bridge_data *bridge)
 290 {
 291         bridge->type = NOT_SUPPORTED;
 292         agp_frontend_cleanup();
 293         agp_backend_cleanup(bridge);
 294         inter_module_unregister("drm_agp");
 295         agp_count--;
 296         module_put(bridge->driver->owner);
 297 }
 298 EXPORT_SYMBOL_GPL(agp_remove_bridge);
 299
 300
 301 static int __init agp_init(void)
 302 {
 303         printk(KERN_INFO "Linux agpgart interface v%d.%d (c) Dave Jones\n",
 304                AGPGART_VERSION_MAJOR, AGPGART_VERSION_MINOR);
 305         return 0;
 306 }
 307
 308 void __exit agp_exit(void)
 309 {
 310 }
 311
 312
 313 MODULE_AUTHOR("Dave Jones <davej@codemonkey.org.uk>");
 314 MODULE_DESCRIPTION("AGP GART driver");
 315 MODULE_LICENSE("GPL and additional rights");
 316
 317 module_init(agp_init);
 318 module_exit(agp_exit);
 319