1/* 2 * AGPGART driver backend routines. 3 * Copyright (C) 2004 Silicon Graphics, Inc. 4 * Copyright (C) 2002-2003 Dave Jones. 5 * Copyright (C) 1999 Jeff Hartmann. 6 * Copyright (C) 1999 Precision Insight, Inc. 7 * Copyright (C) 1999 Xi Graphics, Inc. 8 * 9 * Permission is hereby granted, free of charge, to any person obtaining a 10 * copy of this software and associated documentation files (the "Software"), 11 * to deal in the Software without restriction, including without limitation 12 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 13 * and/or sell copies of the Software, and to permit persons to whom the 14 * Software is furnished to do so, subject to the following conditions: 15 * 16 * The above copyright notice and this permission notice shall be included 17 * in all copies or substantial portions of the Software. 18 * 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 22 * JEFF HARTMANN, DAVE JONES, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, 23 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 24 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE 25 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 26 * 27 * TODO: 28 * - Allocate more than order 0 pages to avoid too much linear map splitting. 29 */ 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/agpgart.h> 38#include <linux/vmalloc.h> 39#include <asm/io.h> 40#include "agp.h" 41 42/* Due to XFree86 brain-damage, we can't go to 1.0 until they 43 * fix some real stupidity. It's only by chance we can bump 44 * past 0.99 at all due to some boolean logic error. */ 45#define AGPGART_VERSION_MAJOR 0 46#define AGPGART_VERSION_MINOR 102 47static const struct agp_version agp_current_version = 48{ 49 .major = AGPGART_VERSION_MAJOR, 50 .minor = AGPGART_VERSION_MINOR, 51}; 52 53struct agp_bridge_data *(*agp_find_bridge)(struct pci_dev *) = 54 &agp_generic_find_bridge; 55 56struct agp_bridge_data *agp_bridge; 57LIST_HEAD(agp_bridges); 58EXPORT_SYMBOL(agp_bridge); 59EXPORT_SYMBOL(agp_bridges); 60EXPORT_SYMBOL(agp_find_bridge); 61 62/** 63 * agp_backend_acquire - attempt to acquire an agp backend. 64 * 65 */ 66struct agp_bridge_data *agp_backend_acquire(struct pci_dev *pdev) 67{ 68 struct agp_bridge_data *bridge; 69 70 bridge = agp_find_bridge(pdev); 71 72 if (!bridge) 73 return NULL; 74 75 if (atomic_read(&bridge->agp_in_use)) 76 return NULL; 77 atomic_inc(&bridge->agp_in_use); 78 return bridge; 79} 80EXPORT_SYMBOL(agp_backend_acquire); 81 82 83/** 84 * agp_backend_release - release the lock on the agp backend. 85 * 86 * The caller must insure that the graphics aperture translation table 87 * is read for use by another entity. 88 * 89 * (Ensure that all memory it bound is unbound.) 90 */ 91void agp_backend_release(struct agp_bridge_data *bridge) 92{ 93 94 if (bridge) 95 atomic_dec(&bridge->agp_in_use); 96} 97EXPORT_SYMBOL(agp_backend_release); 98 99 100static const struct { int mem, agp; } maxes_table[] = { 101 {0, 0}, 102 {32, 4}, 103 {64, 28}, 104 {128, 96}, 105 {256, 204}, 106 {512, 440}, 107 {1024, 942}, 108 {2048, 1920}, 109 {4096, 3932} 110}; 111 112static int agp_find_max(void) 113{ 114 long memory, index, result; 115 116#if PAGE_SHIFT < 20 117 memory = num_physpages >> (20 - PAGE_SHIFT); 118#else 119 memory = num_physpages << (PAGE_SHIFT - 20); 120#endif 121 index = 1; 122 123 while ((memory > maxes_table[index].mem) && (index < 8)) 124 index++; 125 126 result = maxes_table[index - 1].agp + 127 ( (memory - maxes_table[index - 1].mem) * 128 (maxes_table[index].agp - maxes_table[index - 1].agp)) / 129 (maxes_table[index].mem - maxes_table[index - 1].mem); 130 131 result = result << (20 - PAGE_SHIFT); 132 return result; 133} 134 135 136static int agp_backend_initialize(struct agp_bridge_data *bridge) 137{ 138 int size_value, rc, got_gatt=0, got_keylist=0; 139 140 bridge->max_memory_agp = agp_find_max(); 141 bridge->version = &agp_current_version; 142 143 if (bridge->driver->needs_scratch_page) { 144 void *addr = bridge->driver->agp_alloc_page(bridge); 145 146 if (!addr) { 147 printk(KERN_ERR PFX "unable to get memory for scratch page.\n"); 148 return -ENOMEM; 149 } 150 flush_agp_mappings(); 151 152 bridge->scratch_page_real = virt_to_gart(addr); 153 bridge->scratch_page = 154 bridge->driver->mask_memory(bridge, bridge->scratch_page_real, 0); 155 } 156 157 size_value = bridge->driver->fetch_size(); 158 if (size_value == 0) { 159 printk(KERN_ERR PFX "unable to determine aperture size.\n"); 160 rc = -EINVAL; 161 goto err_out; 162 } 163 if (bridge->driver->create_gatt_table(bridge)) { 164 printk(KERN_ERR PFX 165 "unable to get memory for graphics translation table.\n"); 166 rc = -ENOMEM; 167 goto err_out; 168 } 169 got_gatt = 1; 170 171 bridge->key_list = vmalloc(PAGE_SIZE * 4); 172 if (bridge->key_list == NULL) { 173 printk(KERN_ERR PFX "error allocating memory for key lists.\n"); 174 rc = -ENOMEM; 175 goto err_out; 176 } 177 got_keylist = 1; 178 179 memset(bridge->key_list, 0, PAGE_SIZE * 4); 180 181 if (bridge->driver->configure()) { 182 printk(KERN_ERR PFX "error configuring host chipset.\n"); 183 rc = -EINVAL; 184 goto err_out; 185 } 186 187 return 0; 188 189err_out: 190 if (bridge->driver->needs_scratch_page) { 191 bridge->driver->agp_destroy_page( 192 gart_to_virt(bridge->scratch_page_real)); 193 flush_agp_mappings(); 194 } 195 if (got_gatt) 196 bridge->driver->free_gatt_table(bridge); 197 if (got_keylist) { 198 vfree(bridge->key_list); 199 bridge->key_list = NULL; 200 } 201 return rc; 202} 203 204/* cannot be __exit b/c as it could be called from __init code */ 205static void agp_backend_cleanup(struct agp_bridge_data *bridge) 206{ 207 if (bridge->driver->cleanup) 208 bridge->driver->cleanup(); 209 if (bridge->driver->free_gatt_table) 210 bridge->driver->free_gatt_table(bridge); 211 212 vfree(bridge->key_list); 213 bridge->key_list = NULL; 214 215 if (bridge->driver->agp_destroy_page && 216 bridge->driver->needs_scratch_page) { 217 bridge->driver->agp_destroy_page( 218 gart_to_virt(bridge->scratch_page_real)); 219 flush_agp_mappings(); 220 } 221} 222 223/* When we remove the global variable agp_bridge from all drivers 224 * then agp_alloc_bridge and agp_generic_find_bridge need to be updated 225 */ 226 227struct agp_bridge_data *agp_alloc_bridge(void) 228{ 229 struct agp_bridge_data *bridge; 230 231 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL); 232 if (!bridge) 233 return NULL; 234 235 atomic_set(&bridge->agp_in_use, 0); 236 atomic_set(&bridge->current_memory_agp, 0); 237 238 if (list_empty(&agp_bridges)) 239 agp_bridge = bridge; 240 241 return bridge; 242} 243EXPORT_SYMBOL(agp_alloc_bridge); 244 245 246void agp_put_bridge(struct agp_bridge_data *bridge) 247{ 248 kfree(bridge); 249 250 if (list_empty(&agp_bridges)) 251 agp_bridge = NULL; 252} 253EXPORT_SYMBOL(agp_put_bridge); 254 255 256int agp_add_bridge(struct agp_bridge_data *bridge) 257{ 258 int error; 259 260 if (agp_off) 261 return -ENODEV; 262 263 if (!bridge->dev) { 264 printk (KERN_DEBUG PFX "Erk, registering with no pci_dev!\n"); 265 return -EINVAL; 266 } 267 268 /* Grab reference on the chipset driver. */ 269 if (!try_module_get(bridge->driver->owner)) { 270 printk (KERN_INFO PFX "Couldn't lock chipset driver.\n"); 271 return -EINVAL; 272 } 273 274 error = agp_backend_initialize(bridge); 275 if (error) { 276 printk (KERN_INFO PFX "agp_backend_initialize() failed.\n"); 277 goto err_out; 278 } 279 280 if (list_empty(&agp_bridges)) { 281 error = agp_frontend_initialize(); 282 if (error) { 283 printk (KERN_INFO PFX "agp_frontend_initialize() failed.\n"); 284 goto frontend_err; 285 } 286 287 printk(KERN_INFO PFX "AGP aperture is %dM @ 0x%lx\n", 288 bridge->driver->fetch_size(), bridge->gart_bus_addr); 289 290 } 291 292 list_add(&bridge->list, &agp_bridges); 293 return 0; 294 295frontend_err: 296 agp_backend_cleanup(bridge); 297err_out: 298 module_put(bridge->driver->owner); 299 agp_put_bridge(bridge); 300 return error; 301} 302EXPORT_SYMBOL_GPL(agp_add_bridge); 303 304 305void agp_remove_bridge(struct agp_bridge_data *bridge) 306{ 307 agp_backend_cleanup(bridge); 308 list_del(&bridge->list); 309 if (list_empty(&agp_bridges)) 310 agp_frontend_cleanup(); 311 module_put(bridge->driver->owner); 312} 313EXPORT_SYMBOL_GPL(agp_remove_bridge); 314 315int agp_off; 316int agp_try_unsupported_boot; 317EXPORT_SYMBOL(agp_off); 318EXPORT_SYMBOL(agp_try_unsupported_boot); 319 320static int __init agp_init(void) 321{ 322 if (!agp_off) 323 printk(KERN_INFO "Linux agpgart interface v%d.%d (c) Dave Jones\n", 324 AGPGART_VERSION_MAJOR, AGPGART_VERSION_MINOR); 325 return 0; 326} 327 328static void __exit agp_exit(void) 329{ 330} 331 332#ifndef MODULE 333static __init int agp_setup(char *s) 334{ 335 if (!strcmp(s,"off")) 336 agp_off = 1; 337 if (!strcmp(s,"try_unsupported")) 338 agp_try_unsupported_boot = 1; 339 return 1; 340} 341__setup("agp=", agp_setup); 342#endif 343 344MODULE_AUTHOR("Dave Jones <davej@codemonkey.org.uk>"); 345MODULE_DESCRIPTION("AGP GART driver"); 346MODULE_LICENSE("GPL and additional rights"); 347MODULE_ALIAS_MISCDEV(AGPGART_MINOR); 348 349module_init(agp_init); 350module_exit(agp_exit); 351