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