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/slab.h> 34 #include <linux/pagemap.h> 35 #include <linux/miscdevice.h> 36 #include <linux/pm.h> 37 #include <linux/agp_backend.h> 38 #include <linux/agpgart.h> 39 #include <linux/vmalloc.h> 40 #include <asm/io.h> 41 #include "agp.h" 42 43 /* Due to XFree86 brain-damage, we can't go to 1.0 until they 44 * fix some real stupidity. It's only by chance we can bump 45 * past 0.99 at all due to some boolean logic error. */ 46 #define AGPGART_VERSION_MAJOR 0 47 #define AGPGART_VERSION_MINOR 103 48 static const struct agp_version agp_current_version = 49 { 50 .major = AGPGART_VERSION_MAJOR, 51 .minor = AGPGART_VERSION_MINOR, 52 }; 53 54 struct agp_bridge_data *(*agp_find_bridge)(struct pci_dev *) = 55 &agp_generic_find_bridge; 56 57 struct agp_bridge_data *agp_bridge; 58 LIST_HEAD(agp_bridges); 59 EXPORT_SYMBOL(agp_bridge); 60 EXPORT_SYMBOL(agp_bridges); 61 EXPORT_SYMBOL(agp_find_bridge); 62 63 /** 64 * agp_backend_acquire - attempt to acquire an agp backend. 65 * @pdev: the PCI device 66 * 67 */ 68 struct agp_bridge_data *agp_backend_acquire(struct pci_dev *pdev) 69 { 70 struct agp_bridge_data *bridge; 71 72 bridge = agp_find_bridge(pdev); 73 74 if (!bridge) 75 return NULL; 76 77 if (atomic_read(&bridge->agp_in_use)) 78 return NULL; 79 atomic_inc(&bridge->agp_in_use); 80 return bridge; 81 } 82 EXPORT_SYMBOL(agp_backend_acquire); 83 84 85 /** 86 * agp_backend_release - release the lock on the agp backend. 87 * @bridge: the AGP backend to release 88 * 89 * The caller must insure that the graphics aperture translation table 90 * is read for use by another entity. 91 * 92 * (Ensure that all memory it bound is unbound.) 93 */ 94 void agp_backend_release(struct agp_bridge_data *bridge) 95 { 96 97 if (bridge) 98 atomic_dec(&bridge->agp_in_use); 99 } 100 EXPORT_SYMBOL(agp_backend_release); 101 102 103 static const struct { int mem, agp; } maxes_table[] = { 104 {0, 0}, 105 {32, 4}, 106 {64, 28}, 107 {128, 96}, 108 {256, 204}, 109 {512, 440}, 110 {1024, 942}, 111 {2048, 1920}, 112 {4096, 3932} 113 }; 114 115 static int agp_find_max(void) 116 { 117 long memory, index, result; 118 119 #if PAGE_SHIFT < 20 120 memory = totalram_pages() >> (20 - PAGE_SHIFT); 121 #else 122 memory = totalram_pages() << (PAGE_SHIFT - 20); 123 #endif 124 index = 1; 125 126 while ((memory > maxes_table[index].mem) && (index < 8)) 127 index++; 128 129 result = maxes_table[index - 1].agp + 130 ( (memory - maxes_table[index - 1].mem) * 131 (maxes_table[index].agp - maxes_table[index - 1].agp)) / 132 (maxes_table[index].mem - maxes_table[index - 1].mem); 133 134 result = result << (20 - PAGE_SHIFT); 135 return result; 136 } 137 138 139 static int agp_backend_initialize(struct agp_bridge_data *bridge) 140 { 141 int size_value, rc, got_gatt=0, got_keylist=0; 142 143 bridge->max_memory_agp = agp_find_max(); 144 bridge->version = &agp_current_version; 145 146 if (bridge->driver->needs_scratch_page) { 147 struct page *page = bridge->driver->agp_alloc_page(bridge); 148 149 if (!page) { 150 dev_err(&bridge->dev->dev, 151 "can't get memory for scratch page\n"); 152 return -ENOMEM; 153 } 154 155 bridge->scratch_page_page = page; 156 bridge->scratch_page_dma = page_to_phys(page); 157 158 bridge->scratch_page = bridge->driver->mask_memory(bridge, 159 bridge->scratch_page_dma, 0); 160 } 161 162 size_value = bridge->driver->fetch_size(); 163 if (size_value == 0) { 164 dev_err(&bridge->dev->dev, "can't determine aperture size\n"); 165 rc = -EINVAL; 166 goto err_out; 167 } 168 if (bridge->driver->create_gatt_table(bridge)) { 169 dev_err(&bridge->dev->dev, 170 "can't get memory for graphics translation table\n"); 171 rc = -ENOMEM; 172 goto err_out; 173 } 174 got_gatt = 1; 175 176 bridge->key_list = vzalloc(PAGE_SIZE * 4); 177 if (bridge->key_list == NULL) { 178 dev_err(&bridge->dev->dev, 179 "can't allocate memory for key lists\n"); 180 rc = -ENOMEM; 181 goto err_out; 182 } 183 got_keylist = 1; 184 185 /* FIXME vmalloc'd memory not guaranteed contiguous */ 186 187 if (bridge->driver->configure()) { 188 dev_err(&bridge->dev->dev, "error configuring host chipset\n"); 189 rc = -EINVAL; 190 goto err_out; 191 } 192 INIT_LIST_HEAD(&bridge->mapped_list); 193 spin_lock_init(&bridge->mapped_lock); 194 195 return 0; 196 197 err_out: 198 if (bridge->driver->needs_scratch_page) { 199 struct page *page = bridge->scratch_page_page; 200 201 bridge->driver->agp_destroy_page(page, AGP_PAGE_DESTROY_UNMAP); 202 bridge->driver->agp_destroy_page(page, AGP_PAGE_DESTROY_FREE); 203 } 204 if (got_gatt) 205 bridge->driver->free_gatt_table(bridge); 206 if (got_keylist) { 207 vfree(bridge->key_list); 208 bridge->key_list = NULL; 209 } 210 return rc; 211 } 212 213 /* cannot be __exit b/c as it could be called from __init code */ 214 static void agp_backend_cleanup(struct agp_bridge_data *bridge) 215 { 216 if (bridge->driver->cleanup) 217 bridge->driver->cleanup(); 218 if (bridge->driver->free_gatt_table) 219 bridge->driver->free_gatt_table(bridge); 220 221 vfree(bridge->key_list); 222 bridge->key_list = NULL; 223 224 if (bridge->driver->agp_destroy_page && 225 bridge->driver->needs_scratch_page) { 226 struct page *page = bridge->scratch_page_page; 227 228 bridge->driver->agp_destroy_page(page, AGP_PAGE_DESTROY_UNMAP); 229 bridge->driver->agp_destroy_page(page, AGP_PAGE_DESTROY_FREE); 230 } 231 } 232 233 /* When we remove the global variable agp_bridge from all drivers 234 * then agp_alloc_bridge and agp_generic_find_bridge need to be updated 235 */ 236 237 struct agp_bridge_data *agp_alloc_bridge(void) 238 { 239 struct agp_bridge_data *bridge; 240 241 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL); 242 if (!bridge) 243 return NULL; 244 245 atomic_set(&bridge->agp_in_use, 0); 246 atomic_set(&bridge->current_memory_agp, 0); 247 248 if (list_empty(&agp_bridges)) 249 agp_bridge = bridge; 250 251 return bridge; 252 } 253 EXPORT_SYMBOL(agp_alloc_bridge); 254 255 256 void agp_put_bridge(struct agp_bridge_data *bridge) 257 { 258 kfree(bridge); 259 260 if (list_empty(&agp_bridges)) 261 agp_bridge = NULL; 262 } 263 EXPORT_SYMBOL(agp_put_bridge); 264 265 266 int agp_add_bridge(struct agp_bridge_data *bridge) 267 { 268 int error; 269 270 if (agp_off) { 271 error = -ENODEV; 272 goto err_put_bridge; 273 } 274 275 if (!bridge->dev) { 276 printk (KERN_DEBUG PFX "Erk, registering with no pci_dev!\n"); 277 error = -EINVAL; 278 goto err_put_bridge; 279 } 280 281 /* Grab reference on the chipset driver. */ 282 if (!try_module_get(bridge->driver->owner)) { 283 dev_info(&bridge->dev->dev, "can't lock chipset driver\n"); 284 error = -EINVAL; 285 goto err_put_bridge; 286 } 287 288 error = agp_backend_initialize(bridge); 289 if (error) { 290 dev_info(&bridge->dev->dev, 291 "agp_backend_initialize() failed\n"); 292 goto err_out; 293 } 294 295 if (list_empty(&agp_bridges)) { 296 error = agp_frontend_initialize(); 297 if (error) { 298 dev_info(&bridge->dev->dev, 299 "agp_frontend_initialize() failed\n"); 300 goto frontend_err; 301 } 302 303 dev_info(&bridge->dev->dev, "AGP aperture is %dM @ 0x%lx\n", 304 bridge->driver->fetch_size(), bridge->gart_bus_addr); 305 306 } 307 308 list_add(&bridge->list, &agp_bridges); 309 return 0; 310 311 frontend_err: 312 agp_backend_cleanup(bridge); 313 err_out: 314 module_put(bridge->driver->owner); 315 err_put_bridge: 316 agp_put_bridge(bridge); 317 return error; 318 } 319 EXPORT_SYMBOL_GPL(agp_add_bridge); 320 321 322 void agp_remove_bridge(struct agp_bridge_data *bridge) 323 { 324 agp_backend_cleanup(bridge); 325 list_del(&bridge->list); 326 if (list_empty(&agp_bridges)) 327 agp_frontend_cleanup(); 328 module_put(bridge->driver->owner); 329 } 330 EXPORT_SYMBOL_GPL(agp_remove_bridge); 331 332 int agp_off; 333 int agp_try_unsupported_boot; 334 EXPORT_SYMBOL(agp_off); 335 EXPORT_SYMBOL(agp_try_unsupported_boot); 336 337 static int __init agp_init(void) 338 { 339 if (!agp_off) 340 printk(KERN_INFO "Linux agpgart interface v%d.%d\n", 341 AGPGART_VERSION_MAJOR, AGPGART_VERSION_MINOR); 342 return 0; 343 } 344 345 static void __exit agp_exit(void) 346 { 347 } 348 349 #ifndef MODULE 350 static __init int agp_setup(char *s) 351 { 352 if (!strcmp(s,"off")) 353 agp_off = 1; 354 if (!strcmp(s,"try_unsupported")) 355 agp_try_unsupported_boot = 1; 356 return 1; 357 } 358 __setup("agp=", agp_setup); 359 #endif 360 361 MODULE_AUTHOR("Dave Jones, Jeff Hartmann"); 362 MODULE_DESCRIPTION("AGP GART driver"); 363 MODULE_LICENSE("GPL and additional rights"); 364 MODULE_ALIAS_MISCDEV(AGPGART_MINOR); 365 366 module_init(agp_init); 367 module_exit(agp_exit); 368 369