generic.c 33 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249
  1. /*
  2. * AGPGART driver.
  3. * Copyright (C) 2004 Silicon Graphics, Inc.
  4. * Copyright (C) 2002-2005 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, 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/vmalloc.h>
  38. #include <linux/dma-mapping.h>
  39. #include <linux/mm.h>
  40. #include <asm/io.h>
  41. #include <asm/cacheflush.h>
  42. #include <asm/pgtable.h>
  43. #include "agp.h"
  44. __u32 *agp_gatt_table;
  45. int agp_memory_reserved;
  46. /*
  47. * Needed by the Nforce GART driver for the time being. Would be
  48. * nice to do this some other way instead of needing this export.
  49. */
  50. EXPORT_SYMBOL_GPL(agp_memory_reserved);
  51. #if defined(CONFIG_X86)
  52. int map_page_into_agp(struct page *page)
  53. {
  54. int i;
  55. i = change_page_attr(page, 1, PAGE_KERNEL_NOCACHE);
  56. /* Caller's responsibility to call global_flush_tlb() for
  57. * performance reasons */
  58. return i;
  59. }
  60. EXPORT_SYMBOL_GPL(map_page_into_agp);
  61. int unmap_page_from_agp(struct page *page)
  62. {
  63. int i;
  64. i = change_page_attr(page, 1, PAGE_KERNEL);
  65. /* Caller's responsibility to call global_flush_tlb() for
  66. * performance reasons */
  67. return i;
  68. }
  69. EXPORT_SYMBOL_GPL(unmap_page_from_agp);
  70. #endif
  71. /*
  72. * Generic routines for handling agp_memory structures -
  73. * They use the basic page allocation routines to do the brunt of the work.
  74. */
  75. void agp_free_key(int key)
  76. {
  77. if (key < 0)
  78. return;
  79. if (key < MAXKEY)
  80. clear_bit(key, agp_bridge->key_list);
  81. }
  82. EXPORT_SYMBOL(agp_free_key);
  83. static int agp_get_key(void)
  84. {
  85. int bit;
  86. bit = find_first_zero_bit(agp_bridge->key_list, MAXKEY);
  87. if (bit < MAXKEY) {
  88. set_bit(bit, agp_bridge->key_list);
  89. return bit;
  90. }
  91. return -1;
  92. }
  93. struct agp_memory *agp_create_memory(int scratch_pages)
  94. {
  95. struct agp_memory *new;
  96. new = kzalloc(sizeof(struct agp_memory), GFP_KERNEL);
  97. if (new == NULL)
  98. return NULL;
  99. new->key = agp_get_key();
  100. if (new->key < 0) {
  101. kfree(new);
  102. return NULL;
  103. }
  104. new->memory = vmalloc(PAGE_SIZE * scratch_pages);
  105. if (new->memory == NULL) {
  106. agp_free_key(new->key);
  107. kfree(new);
  108. return NULL;
  109. }
  110. new->num_scratch_pages = scratch_pages;
  111. return new;
  112. }
  113. EXPORT_SYMBOL(agp_create_memory);
  114. /**
  115. * agp_free_memory - free memory associated with an agp_memory pointer.
  116. *
  117. * @curr: agp_memory pointer to be freed.
  118. *
  119. * It is the only function that can be called when the backend is not owned
  120. * by the caller. (So it can free memory on client death.)
  121. */
  122. void agp_free_memory(struct agp_memory *curr)
  123. {
  124. size_t i;
  125. if (curr == NULL)
  126. return;
  127. if (curr->is_bound == TRUE)
  128. agp_unbind_memory(curr);
  129. if (curr->type != 0) {
  130. curr->bridge->driver->free_by_type(curr);
  131. return;
  132. }
  133. if (curr->page_count != 0) {
  134. for (i = 0; i < curr->page_count; i++) {
  135. curr->bridge->driver->agp_destroy_page(gart_to_virt(curr->memory[i]));
  136. }
  137. flush_agp_mappings();
  138. }
  139. agp_free_key(curr->key);
  140. vfree(curr->memory);
  141. kfree(curr);
  142. }
  143. EXPORT_SYMBOL(agp_free_memory);
  144. #define ENTRIES_PER_PAGE (PAGE_SIZE / sizeof(unsigned long))
  145. /**
  146. * agp_allocate_memory - allocate a group of pages of a certain type.
  147. *
  148. * @page_count: size_t argument of the number of pages
  149. * @type: u32 argument of the type of memory to be allocated.
  150. *
  151. * Every agp bridge device will allow you to allocate AGP_NORMAL_MEMORY which
  152. * maps to physical ram. Any other type is device dependent.
  153. *
  154. * It returns NULL whenever memory is unavailable.
  155. */
  156. struct agp_memory *agp_allocate_memory(struct agp_bridge_data *bridge,
  157. size_t page_count, u32 type)
  158. {
  159. int scratch_pages;
  160. struct agp_memory *new;
  161. size_t i;
  162. if (!bridge)
  163. return NULL;
  164. if ((atomic_read(&bridge->current_memory_agp) + page_count) > bridge->max_memory_agp)
  165. return NULL;
  166. if (type != 0) {
  167. new = bridge->driver->alloc_by_type(page_count, type);
  168. if (new)
  169. new->bridge = bridge;
  170. return new;
  171. }
  172. scratch_pages = (page_count + ENTRIES_PER_PAGE - 1) / ENTRIES_PER_PAGE;
  173. new = agp_create_memory(scratch_pages);
  174. if (new == NULL)
  175. return NULL;
  176. for (i = 0; i < page_count; i++) {
  177. void *addr = bridge->driver->agp_alloc_page(bridge);
  178. if (addr == NULL) {
  179. agp_free_memory(new);
  180. return NULL;
  181. }
  182. new->memory[i] = virt_to_gart(addr);
  183. new->page_count++;
  184. }
  185. new->bridge = bridge;
  186. flush_agp_mappings();
  187. return new;
  188. }
  189. EXPORT_SYMBOL(agp_allocate_memory);
  190. /* End - Generic routines for handling agp_memory structures */
  191. static int agp_return_size(void)
  192. {
  193. int current_size;
  194. void *temp;
  195. temp = agp_bridge->current_size;
  196. switch (agp_bridge->driver->size_type) {
  197. case U8_APER_SIZE:
  198. current_size = A_SIZE_8(temp)->size;
  199. break;
  200. case U16_APER_SIZE:
  201. current_size = A_SIZE_16(temp)->size;
  202. break;
  203. case U32_APER_SIZE:
  204. current_size = A_SIZE_32(temp)->size;
  205. break;
  206. case LVL2_APER_SIZE:
  207. current_size = A_SIZE_LVL2(temp)->size;
  208. break;
  209. case FIXED_APER_SIZE:
  210. current_size = A_SIZE_FIX(temp)->size;
  211. break;
  212. default:
  213. current_size = 0;
  214. break;
  215. }
  216. current_size -= (agp_memory_reserved / (1024*1024));
  217. if (current_size <0)
  218. current_size = 0;
  219. return current_size;
  220. }
  221. int agp_num_entries(void)
  222. {
  223. int num_entries;
  224. void *temp;
  225. temp = agp_bridge->current_size;
  226. switch (agp_bridge->driver->size_type) {
  227. case U8_APER_SIZE:
  228. num_entries = A_SIZE_8(temp)->num_entries;
  229. break;
  230. case U16_APER_SIZE:
  231. num_entries = A_SIZE_16(temp)->num_entries;
  232. break;
  233. case U32_APER_SIZE:
  234. num_entries = A_SIZE_32(temp)->num_entries;
  235. break;
  236. case LVL2_APER_SIZE:
  237. num_entries = A_SIZE_LVL2(temp)->num_entries;
  238. break;
  239. case FIXED_APER_SIZE:
  240. num_entries = A_SIZE_FIX(temp)->num_entries;
  241. break;
  242. default:
  243. num_entries = 0;
  244. break;
  245. }
  246. num_entries -= agp_memory_reserved>>PAGE_SHIFT;
  247. if (num_entries<0)
  248. num_entries = 0;
  249. return num_entries;
  250. }
  251. EXPORT_SYMBOL_GPL(agp_num_entries);
  252. /**
  253. * agp_copy_info - copy bridge state information
  254. *
  255. * @info: agp_kern_info pointer. The caller should insure that this pointer is valid.
  256. *
  257. * This function copies information about the agp bridge device and the state of
  258. * the agp backend into an agp_kern_info pointer.
  259. */
  260. int agp_copy_info(struct agp_bridge_data *bridge, struct agp_kern_info *info)
  261. {
  262. memset(info, 0, sizeof(struct agp_kern_info));
  263. if (!bridge) {
  264. info->chipset = NOT_SUPPORTED;
  265. return -EIO;
  266. }
  267. info->version.major = bridge->version->major;
  268. info->version.minor = bridge->version->minor;
  269. info->chipset = SUPPORTED;
  270. info->device = bridge->dev;
  271. if (bridge->mode & AGPSTAT_MODE_3_0)
  272. info->mode = bridge->mode & ~AGP3_RESERVED_MASK;
  273. else
  274. info->mode = bridge->mode & ~AGP2_RESERVED_MASK;
  275. info->aper_base = bridge->gart_bus_addr;
  276. info->aper_size = agp_return_size();
  277. info->max_memory = bridge->max_memory_agp;
  278. info->current_memory = atomic_read(&bridge->current_memory_agp);
  279. info->cant_use_aperture = bridge->driver->cant_use_aperture;
  280. info->vm_ops = bridge->vm_ops;
  281. info->page_mask = ~0UL;
  282. return 0;
  283. }
  284. EXPORT_SYMBOL(agp_copy_info);
  285. /* End - Routine to copy over information structure */
  286. /*
  287. * Routines for handling swapping of agp_memory into the GATT -
  288. * These routines take agp_memory and insert them into the GATT.
  289. * They call device specific routines to actually write to the GATT.
  290. */
  291. /**
  292. * agp_bind_memory - Bind an agp_memory structure into the GATT.
  293. *
  294. * @curr: agp_memory pointer
  295. * @pg_start: an offset into the graphics aperture translation table
  296. *
  297. * It returns -EINVAL if the pointer == NULL.
  298. * It returns -EBUSY if the area of the table requested is already in use.
  299. */
  300. int agp_bind_memory(struct agp_memory *curr, off_t pg_start)
  301. {
  302. int ret_val;
  303. if (curr == NULL)
  304. return -EINVAL;
  305. if (curr->is_bound == TRUE) {
  306. printk(KERN_INFO PFX "memory %p is already bound!\n", curr);
  307. return -EINVAL;
  308. }
  309. if (curr->is_flushed == FALSE) {
  310. curr->bridge->driver->cache_flush();
  311. curr->is_flushed = TRUE;
  312. }
  313. ret_val = curr->bridge->driver->insert_memory(curr, pg_start, curr->type);
  314. if (ret_val != 0)
  315. return ret_val;
  316. curr->is_bound = TRUE;
  317. curr->pg_start = pg_start;
  318. return 0;
  319. }
  320. EXPORT_SYMBOL(agp_bind_memory);
  321. /**
  322. * agp_unbind_memory - Removes an agp_memory structure from the GATT
  323. *
  324. * @curr: agp_memory pointer to be removed from the GATT.
  325. *
  326. * It returns -EINVAL if this piece of agp_memory is not currently bound to
  327. * the graphics aperture translation table or if the agp_memory pointer == NULL
  328. */
  329. int agp_unbind_memory(struct agp_memory *curr)
  330. {
  331. int ret_val;
  332. if (curr == NULL)
  333. return -EINVAL;
  334. if (curr->is_bound != TRUE) {
  335. printk(KERN_INFO PFX "memory %p was not bound!\n", curr);
  336. return -EINVAL;
  337. }
  338. ret_val = curr->bridge->driver->remove_memory(curr, curr->pg_start, curr->type);
  339. if (ret_val != 0)
  340. return ret_val;
  341. curr->is_bound = FALSE;
  342. curr->pg_start = 0;
  343. return 0;
  344. }
  345. EXPORT_SYMBOL(agp_unbind_memory);
  346. /* End - Routines for handling swapping of agp_memory into the GATT */
  347. /* Generic Agp routines - Start */
  348. static void agp_v2_parse_one(u32 *requested_mode, u32 *bridge_agpstat, u32 *vga_agpstat)
  349. {
  350. u32 tmp;
  351. if (*requested_mode & AGP2_RESERVED_MASK) {
  352. printk(KERN_INFO PFX "reserved bits set (%x) in mode 0x%x. Fixed.\n",
  353. *requested_mode & AGP2_RESERVED_MASK, *requested_mode);
  354. *requested_mode &= ~AGP2_RESERVED_MASK;
  355. }
  356. /*
  357. * Some dumb bridges are programmed to disobey the AGP2 spec.
  358. * This is likely a BIOS misprogramming rather than poweron default, or
  359. * it would be a lot more common.
  360. * https://bugs.freedesktop.org/show_bug.cgi?id=8816
  361. * AGPv2 spec 6.1.9 states:
  362. * The RATE field indicates the data transfer rates supported by this
  363. * device. A.G.P. devices must report all that apply.
  364. * Fix them up as best we can.
  365. */
  366. switch (*bridge_agpstat & 7) {
  367. case 4:
  368. *bridge_agpstat |= (AGPSTAT2_2X | AGPSTAT2_1X);
  369. printk(KERN_INFO PFX "BIOS bug. AGP bridge claims to only support x4 rate"
  370. "Fixing up support for x2 & x1\n");
  371. break;
  372. case 2:
  373. *bridge_agpstat |= AGPSTAT2_1X;
  374. printk(KERN_INFO PFX "BIOS bug. AGP bridge claims to only support x2 rate"
  375. "Fixing up support for x1\n");
  376. break;
  377. default:
  378. break;
  379. }
  380. /* Check the speed bits make sense. Only one should be set. */
  381. tmp = *requested_mode & 7;
  382. switch (tmp) {
  383. case 0:
  384. printk(KERN_INFO PFX "%s tried to set rate=x0. Setting to x1 mode.\n", current->comm);
  385. *requested_mode |= AGPSTAT2_1X;
  386. break;
  387. case 1:
  388. case 2:
  389. break;
  390. case 3:
  391. *requested_mode &= ~(AGPSTAT2_1X); /* rate=2 */
  392. break;
  393. case 4:
  394. break;
  395. case 5:
  396. case 6:
  397. case 7:
  398. *requested_mode &= ~(AGPSTAT2_1X|AGPSTAT2_2X); /* rate=4*/
  399. break;
  400. }
  401. /* disable SBA if it's not supported */
  402. if (!((*bridge_agpstat & AGPSTAT_SBA) && (*vga_agpstat & AGPSTAT_SBA) && (*requested_mode & AGPSTAT_SBA)))
  403. *bridge_agpstat &= ~AGPSTAT_SBA;
  404. /* Set rate */
  405. if (!((*bridge_agpstat & AGPSTAT2_4X) && (*vga_agpstat & AGPSTAT2_4X) && (*requested_mode & AGPSTAT2_4X)))
  406. *bridge_agpstat &= ~AGPSTAT2_4X;
  407. if (!((*bridge_agpstat & AGPSTAT2_2X) && (*vga_agpstat & AGPSTAT2_2X) && (*requested_mode & AGPSTAT2_2X)))
  408. *bridge_agpstat &= ~AGPSTAT2_2X;
  409. if (!((*bridge_agpstat & AGPSTAT2_1X) && (*vga_agpstat & AGPSTAT2_1X) && (*requested_mode & AGPSTAT2_1X)))
  410. *bridge_agpstat &= ~AGPSTAT2_1X;
  411. /* Now we know what mode it should be, clear out the unwanted bits. */
  412. if (*bridge_agpstat & AGPSTAT2_4X)
  413. *bridge_agpstat &= ~(AGPSTAT2_1X | AGPSTAT2_2X); /* 4X */
  414. if (*bridge_agpstat & AGPSTAT2_2X)
  415. *bridge_agpstat &= ~(AGPSTAT2_1X | AGPSTAT2_4X); /* 2X */
  416. if (*bridge_agpstat & AGPSTAT2_1X)
  417. *bridge_agpstat &= ~(AGPSTAT2_2X | AGPSTAT2_4X); /* 1X */
  418. /* Apply any errata. */
  419. if (agp_bridge->flags & AGP_ERRATA_FASTWRITES)
  420. *bridge_agpstat &= ~AGPSTAT_FW;
  421. if (agp_bridge->flags & AGP_ERRATA_SBA)
  422. *bridge_agpstat &= ~AGPSTAT_SBA;
  423. if (agp_bridge->flags & AGP_ERRATA_1X) {
  424. *bridge_agpstat &= ~(AGPSTAT2_2X | AGPSTAT2_4X);
  425. *bridge_agpstat |= AGPSTAT2_1X;
  426. }
  427. /* If we've dropped down to 1X, disable fast writes. */
  428. if (*bridge_agpstat & AGPSTAT2_1X)
  429. *bridge_agpstat &= ~AGPSTAT_FW;
  430. }
  431. /*
  432. * requested_mode = Mode requested by (typically) X.
  433. * bridge_agpstat = PCI_AGP_STATUS from agp bridge.
  434. * vga_agpstat = PCI_AGP_STATUS from graphic card.
  435. */
  436. static void agp_v3_parse_one(u32 *requested_mode, u32 *bridge_agpstat, u32 *vga_agpstat)
  437. {
  438. u32 origbridge=*bridge_agpstat, origvga=*vga_agpstat;
  439. u32 tmp;
  440. if (*requested_mode & AGP3_RESERVED_MASK) {
  441. printk(KERN_INFO PFX "reserved bits set (%x) in mode 0x%x. Fixed.\n",
  442. *requested_mode & AGP3_RESERVED_MASK, *requested_mode);
  443. *requested_mode &= ~AGP3_RESERVED_MASK;
  444. }
  445. /* Check the speed bits make sense. */
  446. tmp = *requested_mode & 7;
  447. if (tmp == 0) {
  448. printk(KERN_INFO PFX "%s tried to set rate=x0. Setting to AGP3 x4 mode.\n", current->comm);
  449. *requested_mode |= AGPSTAT3_4X;
  450. }
  451. if (tmp >= 3) {
  452. printk(KERN_INFO PFX "%s tried to set rate=x%d. Setting to AGP3 x8 mode.\n", current->comm, tmp * 4);
  453. *requested_mode = (*requested_mode & ~7) | AGPSTAT3_8X;
  454. }
  455. /* ARQSZ - Set the value to the maximum one.
  456. * Don't allow the mode register to override values. */
  457. *bridge_agpstat = ((*bridge_agpstat & ~AGPSTAT_ARQSZ) |
  458. max_t(u32,(*bridge_agpstat & AGPSTAT_ARQSZ),(*vga_agpstat & AGPSTAT_ARQSZ)));
  459. /* Calibration cycle.
  460. * Don't allow the mode register to override values. */
  461. *bridge_agpstat = ((*bridge_agpstat & ~AGPSTAT_CAL_MASK) |
  462. min_t(u32,(*bridge_agpstat & AGPSTAT_CAL_MASK),(*vga_agpstat & AGPSTAT_CAL_MASK)));
  463. /* SBA *must* be supported for AGP v3 */
  464. *bridge_agpstat |= AGPSTAT_SBA;
  465. /*
  466. * Set speed.
  467. * Check for invalid speeds. This can happen when applications
  468. * written before the AGP 3.0 standard pass AGP2.x modes to AGP3 hardware
  469. */
  470. if (*requested_mode & AGPSTAT_MODE_3_0) {
  471. /*
  472. * Caller hasn't a clue what it is doing. Bridge is in 3.0 mode,
  473. * have been passed a 3.0 mode, but with 2.x speed bits set.
  474. * AGP2.x 4x -> AGP3.0 4x.
  475. */
  476. if (*requested_mode & AGPSTAT2_4X) {
  477. printk(KERN_INFO PFX "%s passes broken AGP3 flags (%x). Fixed.\n",
  478. current->comm, *requested_mode);
  479. *requested_mode &= ~AGPSTAT2_4X;
  480. *requested_mode |= AGPSTAT3_4X;
  481. }
  482. } else {
  483. /*
  484. * The caller doesn't know what they are doing. We are in 3.0 mode,
  485. * but have been passed an AGP 2.x mode.
  486. * Convert AGP 1x,2x,4x -> AGP 3.0 4x.
  487. */
  488. printk(KERN_INFO PFX "%s passes broken AGP2 flags (%x) in AGP3 mode. Fixed.\n",
  489. current->comm, *requested_mode);
  490. *requested_mode &= ~(AGPSTAT2_4X | AGPSTAT2_2X | AGPSTAT2_1X);
  491. *requested_mode |= AGPSTAT3_4X;
  492. }
  493. if (*requested_mode & AGPSTAT3_8X) {
  494. if (!(*bridge_agpstat & AGPSTAT3_8X)) {
  495. *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
  496. *bridge_agpstat |= AGPSTAT3_4X;
  497. printk(KERN_INFO PFX "%s requested AGPx8 but bridge not capable.\n", current->comm);
  498. return;
  499. }
  500. if (!(*vga_agpstat & AGPSTAT3_8X)) {
  501. *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
  502. *bridge_agpstat |= AGPSTAT3_4X;
  503. printk(KERN_INFO PFX "%s requested AGPx8 but graphic card not capable.\n", current->comm);
  504. return;
  505. }
  506. /* All set, bridge & device can do AGP x8*/
  507. *bridge_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
  508. goto done;
  509. } else if (*requested_mode & AGPSTAT3_4X) {
  510. *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
  511. *bridge_agpstat |= AGPSTAT3_4X;
  512. goto done;
  513. } else {
  514. /*
  515. * If we didn't specify an AGP mode, we see if both
  516. * the graphics card, and the bridge can do x8, and use if so.
  517. * If not, we fall back to x4 mode.
  518. */
  519. if ((*bridge_agpstat & AGPSTAT3_8X) && (*vga_agpstat & AGPSTAT3_8X)) {
  520. printk(KERN_INFO PFX "No AGP mode specified. Setting to highest mode "
  521. "supported by bridge & card (x8).\n");
  522. *bridge_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
  523. *vga_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
  524. } else {
  525. printk(KERN_INFO PFX "Fell back to AGPx4 mode because");
  526. if (!(*bridge_agpstat & AGPSTAT3_8X)) {
  527. printk(KERN_INFO PFX "bridge couldn't do x8. bridge_agpstat:%x (orig=%x)\n",
  528. *bridge_agpstat, origbridge);
  529. *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
  530. *bridge_agpstat |= AGPSTAT3_4X;
  531. }
  532. if (!(*vga_agpstat & AGPSTAT3_8X)) {
  533. printk(KERN_INFO PFX "graphics card couldn't do x8. vga_agpstat:%x (orig=%x)\n",
  534. *vga_agpstat, origvga);
  535. *vga_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
  536. *vga_agpstat |= AGPSTAT3_4X;
  537. }
  538. }
  539. }
  540. done:
  541. /* Apply any errata. */
  542. if (agp_bridge->flags & AGP_ERRATA_FASTWRITES)
  543. *bridge_agpstat &= ~AGPSTAT_FW;
  544. if (agp_bridge->flags & AGP_ERRATA_SBA)
  545. *bridge_agpstat &= ~AGPSTAT_SBA;
  546. if (agp_bridge->flags & AGP_ERRATA_1X) {
  547. *bridge_agpstat &= ~(AGPSTAT2_2X | AGPSTAT2_4X);
  548. *bridge_agpstat |= AGPSTAT2_1X;
  549. }
  550. }
  551. /**
  552. * agp_collect_device_status - determine correct agp_cmd from various agp_stat's
  553. * @bridge: an agp_bridge_data struct allocated for the AGP host bridge.
  554. * @requested_mode: requested agp_stat from userspace (Typically from X)
  555. * @bridge_agpstat: current agp_stat from AGP bridge.
  556. *
  557. * This function will hunt for an AGP graphics card, and try to match
  558. * the requested mode to the capabilities of both the bridge and the card.
  559. */
  560. u32 agp_collect_device_status(struct agp_bridge_data *bridge, u32 requested_mode, u32 bridge_agpstat)
  561. {
  562. struct pci_dev *device = NULL;
  563. u32 vga_agpstat;
  564. u8 cap_ptr;
  565. for (;;) {
  566. device = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, device);
  567. if (!device) {
  568. printk(KERN_INFO PFX "Couldn't find an AGP VGA controller.\n");
  569. return 0;
  570. }
  571. cap_ptr = pci_find_capability(device, PCI_CAP_ID_AGP);
  572. if (cap_ptr)
  573. break;
  574. }
  575. /*
  576. * Ok, here we have a AGP device. Disable impossible
  577. * settings, and adjust the readqueue to the minimum.
  578. */
  579. pci_read_config_dword(device, cap_ptr+PCI_AGP_STATUS, &vga_agpstat);
  580. /* adjust RQ depth */
  581. bridge_agpstat = ((bridge_agpstat & ~AGPSTAT_RQ_DEPTH) |
  582. min_t(u32, (requested_mode & AGPSTAT_RQ_DEPTH),
  583. min_t(u32, (bridge_agpstat & AGPSTAT_RQ_DEPTH), (vga_agpstat & AGPSTAT_RQ_DEPTH))));
  584. /* disable FW if it's not supported */
  585. if (!((bridge_agpstat & AGPSTAT_FW) &&
  586. (vga_agpstat & AGPSTAT_FW) &&
  587. (requested_mode & AGPSTAT_FW)))
  588. bridge_agpstat &= ~AGPSTAT_FW;
  589. /* Check to see if we are operating in 3.0 mode */
  590. if (agp_bridge->mode & AGPSTAT_MODE_3_0)
  591. agp_v3_parse_one(&requested_mode, &bridge_agpstat, &vga_agpstat);
  592. else
  593. agp_v2_parse_one(&requested_mode, &bridge_agpstat, &vga_agpstat);
  594. pci_dev_put(device);
  595. return bridge_agpstat;
  596. }
  597. EXPORT_SYMBOL(agp_collect_device_status);
  598. void agp_device_command(u32 bridge_agpstat, int agp_v3)
  599. {
  600. struct pci_dev *device = NULL;
  601. int mode;
  602. mode = bridge_agpstat & 0x7;
  603. if (agp_v3)
  604. mode *= 4;
  605. for_each_pci_dev(device) {
  606. u8 agp = pci_find_capability(device, PCI_CAP_ID_AGP);
  607. if (!agp)
  608. continue;
  609. printk(KERN_INFO PFX "Putting AGP V%d device at %s into %dx mode\n",
  610. agp_v3 ? 3 : 2, pci_name(device), mode);
  611. pci_write_config_dword(device, agp + PCI_AGP_COMMAND, bridge_agpstat);
  612. }
  613. }
  614. EXPORT_SYMBOL(agp_device_command);
  615. void get_agp_version(struct agp_bridge_data *bridge)
  616. {
  617. u32 ncapid;
  618. /* Exit early if already set by errata workarounds. */
  619. if (bridge->major_version != 0)
  620. return;
  621. pci_read_config_dword(bridge->dev, bridge->capndx, &ncapid);
  622. bridge->major_version = (ncapid >> AGP_MAJOR_VERSION_SHIFT) & 0xf;
  623. bridge->minor_version = (ncapid >> AGP_MINOR_VERSION_SHIFT) & 0xf;
  624. }
  625. EXPORT_SYMBOL(get_agp_version);
  626. void agp_generic_enable(struct agp_bridge_data *bridge, u32 requested_mode)
  627. {
  628. u32 bridge_agpstat, temp;
  629. get_agp_version(agp_bridge);
  630. printk(KERN_INFO PFX "Found an AGP %d.%d compliant device at %s.\n",
  631. agp_bridge->major_version,
  632. agp_bridge->minor_version,
  633. pci_name(agp_bridge->dev));
  634. pci_read_config_dword(agp_bridge->dev,
  635. agp_bridge->capndx + PCI_AGP_STATUS, &bridge_agpstat);
  636. bridge_agpstat = agp_collect_device_status(agp_bridge, requested_mode, bridge_agpstat);
  637. if (bridge_agpstat == 0)
  638. /* Something bad happened. FIXME: Return error code? */
  639. return;
  640. bridge_agpstat |= AGPSTAT_AGP_ENABLE;
  641. /* Do AGP version specific frobbing. */
  642. if (bridge->major_version >= 3) {
  643. if (bridge->mode & AGPSTAT_MODE_3_0) {
  644. /* If we have 3.5, we can do the isoch stuff. */
  645. if (bridge->minor_version >= 5)
  646. agp_3_5_enable(bridge);
  647. agp_device_command(bridge_agpstat, TRUE);
  648. return;
  649. } else {
  650. /* Disable calibration cycle in RX91<1> when not in AGP3.0 mode of operation.*/
  651. bridge_agpstat &= ~(7<<10) ;
  652. pci_read_config_dword(bridge->dev,
  653. bridge->capndx+AGPCTRL, &temp);
  654. temp |= (1<<9);
  655. pci_write_config_dword(bridge->dev,
  656. bridge->capndx+AGPCTRL, temp);
  657. printk(KERN_INFO PFX "Device is in legacy mode,"
  658. " falling back to 2.x\n");
  659. }
  660. }
  661. /* AGP v<3 */
  662. agp_device_command(bridge_agpstat, FALSE);
  663. }
  664. EXPORT_SYMBOL(agp_generic_enable);
  665. int agp_generic_create_gatt_table(struct agp_bridge_data *bridge)
  666. {
  667. char *table;
  668. char *table_end;
  669. int size;
  670. int page_order;
  671. int num_entries;
  672. int i;
  673. void *temp;
  674. struct page *page;
  675. /* The generic routines can't handle 2 level gatt's */
  676. if (bridge->driver->size_type == LVL2_APER_SIZE)
  677. return -EINVAL;
  678. table = NULL;
  679. i = bridge->aperture_size_idx;
  680. temp = bridge->current_size;
  681. size = page_order = num_entries = 0;
  682. if (bridge->driver->size_type != FIXED_APER_SIZE) {
  683. do {
  684. switch (bridge->driver->size_type) {
  685. case U8_APER_SIZE:
  686. size = A_SIZE_8(temp)->size;
  687. page_order =
  688. A_SIZE_8(temp)->page_order;
  689. num_entries =
  690. A_SIZE_8(temp)->num_entries;
  691. break;
  692. case U16_APER_SIZE:
  693. size = A_SIZE_16(temp)->size;
  694. page_order = A_SIZE_16(temp)->page_order;
  695. num_entries = A_SIZE_16(temp)->num_entries;
  696. break;
  697. case U32_APER_SIZE:
  698. size = A_SIZE_32(temp)->size;
  699. page_order = A_SIZE_32(temp)->page_order;
  700. num_entries = A_SIZE_32(temp)->num_entries;
  701. break;
  702. /* This case will never really happen. */
  703. case FIXED_APER_SIZE:
  704. case LVL2_APER_SIZE:
  705. default:
  706. size = page_order = num_entries = 0;
  707. break;
  708. }
  709. table = alloc_gatt_pages(page_order);
  710. if (table == NULL) {
  711. i++;
  712. switch (bridge->driver->size_type) {
  713. case U8_APER_SIZE:
  714. bridge->current_size = A_IDX8(bridge);
  715. break;
  716. case U16_APER_SIZE:
  717. bridge->current_size = A_IDX16(bridge);
  718. break;
  719. case U32_APER_SIZE:
  720. bridge->current_size = A_IDX32(bridge);
  721. break;
  722. /* These cases will never really happen. */
  723. case FIXED_APER_SIZE:
  724. case LVL2_APER_SIZE:
  725. default:
  726. break;
  727. }
  728. temp = bridge->current_size;
  729. } else {
  730. bridge->aperture_size_idx = i;
  731. }
  732. } while (!table && (i < bridge->driver->num_aperture_sizes));
  733. } else {
  734. size = ((struct aper_size_info_fixed *) temp)->size;
  735. page_order = ((struct aper_size_info_fixed *) temp)->page_order;
  736. num_entries = ((struct aper_size_info_fixed *) temp)->num_entries;
  737. table = alloc_gatt_pages(page_order);
  738. }
  739. if (table == NULL)
  740. return -ENOMEM;
  741. table_end = table + ((PAGE_SIZE * (1 << page_order)) - 1);
  742. for (page = virt_to_page(table); page <= virt_to_page(table_end); page++)
  743. SetPageReserved(page);
  744. bridge->gatt_table_real = (u32 *) table;
  745. agp_gatt_table = (void *)table;
  746. bridge->driver->cache_flush();
  747. bridge->gatt_table = ioremap_nocache(virt_to_gart(table),
  748. (PAGE_SIZE * (1 << page_order)));
  749. bridge->driver->cache_flush();
  750. if (bridge->gatt_table == NULL) {
  751. for (page = virt_to_page(table); page <= virt_to_page(table_end); page++)
  752. ClearPageReserved(page);
  753. free_gatt_pages(table, page_order);
  754. return -ENOMEM;
  755. }
  756. bridge->gatt_bus_addr = virt_to_gart(bridge->gatt_table_real);
  757. /* AK: bogus, should encode addresses > 4GB */
  758. for (i = 0; i < num_entries; i++) {
  759. writel(bridge->scratch_page, bridge->gatt_table+i);
  760. readl(bridge->gatt_table+i); /* PCI Posting. */
  761. }
  762. return 0;
  763. }
  764. EXPORT_SYMBOL(agp_generic_create_gatt_table);
  765. int agp_generic_free_gatt_table(struct agp_bridge_data *bridge)
  766. {
  767. int page_order;
  768. char *table, *table_end;
  769. void *temp;
  770. struct page *page;
  771. temp = bridge->current_size;
  772. switch (bridge->driver->size_type) {
  773. case U8_APER_SIZE:
  774. page_order = A_SIZE_8(temp)->page_order;
  775. break;
  776. case U16_APER_SIZE:
  777. page_order = A_SIZE_16(temp)->page_order;
  778. break;
  779. case U32_APER_SIZE:
  780. page_order = A_SIZE_32(temp)->page_order;
  781. break;
  782. case FIXED_APER_SIZE:
  783. page_order = A_SIZE_FIX(temp)->page_order;
  784. break;
  785. case LVL2_APER_SIZE:
  786. /* The generic routines can't deal with 2 level gatt's */
  787. return -EINVAL;
  788. break;
  789. default:
  790. page_order = 0;
  791. break;
  792. }
  793. /* Do not worry about freeing memory, because if this is
  794. * called, then all agp memory is deallocated and removed
  795. * from the table. */
  796. iounmap(bridge->gatt_table);
  797. table = (char *) bridge->gatt_table_real;
  798. table_end = table + ((PAGE_SIZE * (1 << page_order)) - 1);
  799. for (page = virt_to_page(table); page <= virt_to_page(table_end); page++)
  800. ClearPageReserved(page);
  801. free_gatt_pages(bridge->gatt_table_real, page_order);
  802. agp_gatt_table = NULL;
  803. bridge->gatt_table = NULL;
  804. bridge->gatt_table_real = NULL;
  805. bridge->gatt_bus_addr = 0;
  806. return 0;
  807. }
  808. EXPORT_SYMBOL(agp_generic_free_gatt_table);
  809. int agp_generic_insert_memory(struct agp_memory * mem, off_t pg_start, int type)
  810. {
  811. int num_entries;
  812. size_t i;
  813. off_t j;
  814. void *temp;
  815. struct agp_bridge_data *bridge;
  816. bridge = mem->bridge;
  817. if (!bridge)
  818. return -EINVAL;
  819. if (mem->page_count == 0)
  820. return 0;
  821. temp = bridge->current_size;
  822. switch (bridge->driver->size_type) {
  823. case U8_APER_SIZE:
  824. num_entries = A_SIZE_8(temp)->num_entries;
  825. break;
  826. case U16_APER_SIZE:
  827. num_entries = A_SIZE_16(temp)->num_entries;
  828. break;
  829. case U32_APER_SIZE:
  830. num_entries = A_SIZE_32(temp)->num_entries;
  831. break;
  832. case FIXED_APER_SIZE:
  833. num_entries = A_SIZE_FIX(temp)->num_entries;
  834. break;
  835. case LVL2_APER_SIZE:
  836. /* The generic routines can't deal with 2 level gatt's */
  837. return -EINVAL;
  838. break;
  839. default:
  840. num_entries = 0;
  841. break;
  842. }
  843. num_entries -= agp_memory_reserved/PAGE_SIZE;
  844. if (num_entries < 0) num_entries = 0;
  845. if (type != 0 || mem->type != 0) {
  846. /* The generic routines know nothing of memory types */
  847. return -EINVAL;
  848. }
  849. /* AK: could wrap */
  850. if ((pg_start + mem->page_count) > num_entries)
  851. return -EINVAL;
  852. j = pg_start;
  853. while (j < (pg_start + mem->page_count)) {
  854. if (!PGE_EMPTY(bridge, readl(bridge->gatt_table+j)))
  855. return -EBUSY;
  856. j++;
  857. }
  858. if (mem->is_flushed == FALSE) {
  859. bridge->driver->cache_flush();
  860. mem->is_flushed = TRUE;
  861. }
  862. for (i = 0, j = pg_start; i < mem->page_count; i++, j++) {
  863. writel(bridge->driver->mask_memory(bridge, mem->memory[i], mem->type), bridge->gatt_table+j);
  864. }
  865. readl(bridge->gatt_table+j-1); /* PCI Posting. */
  866. bridge->driver->tlb_flush(mem);
  867. return 0;
  868. }
  869. EXPORT_SYMBOL(agp_generic_insert_memory);
  870. int agp_generic_remove_memory(struct agp_memory *mem, off_t pg_start, int type)
  871. {
  872. size_t i;
  873. struct agp_bridge_data *bridge;
  874. bridge = mem->bridge;
  875. if (!bridge)
  876. return -EINVAL;
  877. if (mem->page_count == 0)
  878. return 0;
  879. if (type != 0 || mem->type != 0) {
  880. /* The generic routines know nothing of memory types */
  881. return -EINVAL;
  882. }
  883. /* AK: bogus, should encode addresses > 4GB */
  884. for (i = pg_start; i < (mem->page_count + pg_start); i++) {
  885. writel(bridge->scratch_page, bridge->gatt_table+i);
  886. }
  887. readl(bridge->gatt_table+i-1); /* PCI Posting. */
  888. bridge->driver->tlb_flush(mem);
  889. return 0;
  890. }
  891. EXPORT_SYMBOL(agp_generic_remove_memory);
  892. struct agp_memory *agp_generic_alloc_by_type(size_t page_count, int type)
  893. {
  894. return NULL;
  895. }
  896. EXPORT_SYMBOL(agp_generic_alloc_by_type);
  897. void agp_generic_free_by_type(struct agp_memory *curr)
  898. {
  899. vfree(curr->memory);
  900. agp_free_key(curr->key);
  901. kfree(curr);
  902. }
  903. EXPORT_SYMBOL(agp_generic_free_by_type);
  904. /*
  905. * Basic Page Allocation Routines -
  906. * These routines handle page allocation and by default they reserve the allocated
  907. * memory. They also handle incrementing the current_memory_agp value, Which is checked
  908. * against a maximum value.
  909. */
  910. void *agp_generic_alloc_page(struct agp_bridge_data *bridge)
  911. {
  912. struct page * page;
  913. page = alloc_page(GFP_KERNEL | GFP_DMA32);
  914. if (page == NULL)
  915. return NULL;
  916. map_page_into_agp(page);
  917. get_page(page);
  918. SetPageLocked(page);
  919. atomic_inc(&agp_bridge->current_memory_agp);
  920. return page_address(page);
  921. }
  922. EXPORT_SYMBOL(agp_generic_alloc_page);
  923. void agp_generic_destroy_page(void *addr)
  924. {
  925. struct page *page;
  926. if (addr == NULL)
  927. return;
  928. page = virt_to_page(addr);
  929. unmap_page_from_agp(page);
  930. put_page(page);
  931. unlock_page(page);
  932. free_page((unsigned long)addr);
  933. atomic_dec(&agp_bridge->current_memory_agp);
  934. }
  935. EXPORT_SYMBOL(agp_generic_destroy_page);
  936. /* End Basic Page Allocation Routines */
  937. /**
  938. * agp_enable - initialise the agp point-to-point connection.
  939. *
  940. * @mode: agp mode register value to configure with.
  941. */
  942. void agp_enable(struct agp_bridge_data *bridge, u32 mode)
  943. {
  944. if (!bridge)
  945. return;
  946. bridge->driver->agp_enable(bridge, mode);
  947. }
  948. EXPORT_SYMBOL(agp_enable);
  949. /* When we remove the global variable agp_bridge from all drivers
  950. * then agp_alloc_bridge and agp_generic_find_bridge need to be updated
  951. */
  952. struct agp_bridge_data *agp_generic_find_bridge(struct pci_dev *pdev)
  953. {
  954. if (list_empty(&agp_bridges))
  955. return NULL;
  956. return agp_bridge;
  957. }
  958. static void ipi_handler(void *null)
  959. {
  960. flush_agp_cache();
  961. }
  962. void global_cache_flush(void)
  963. {
  964. if (on_each_cpu(ipi_handler, NULL, 1, 1) != 0)
  965. panic(PFX "timed out waiting for the other CPUs!\n");
  966. }
  967. EXPORT_SYMBOL(global_cache_flush);
  968. unsigned long agp_generic_mask_memory(struct agp_bridge_data *bridge,
  969. unsigned long addr, int type)
  970. {
  971. /* memory type is ignored in the generic routine */
  972. if (bridge->driver->masks)
  973. return addr | bridge->driver->masks[0].mask;
  974. else
  975. return addr;
  976. }
  977. EXPORT_SYMBOL(agp_generic_mask_memory);
  978. /*
  979. * These functions are implemented according to the AGPv3 spec,
  980. * which covers implementation details that had previously been
  981. * left open.
  982. */
  983. int agp3_generic_fetch_size(void)
  984. {
  985. u16 temp_size;
  986. int i;
  987. struct aper_size_info_16 *values;
  988. pci_read_config_word(agp_bridge->dev, agp_bridge->capndx+AGPAPSIZE, &temp_size);
  989. values = A_SIZE_16(agp_bridge->driver->aperture_sizes);
  990. for (i = 0; i < agp_bridge->driver->num_aperture_sizes; i++) {
  991. if (temp_size == values[i].size_value) {
  992. agp_bridge->previous_size =
  993. agp_bridge->current_size = (void *) (values + i);
  994. agp_bridge->aperture_size_idx = i;
  995. return values[i].size;
  996. }
  997. }
  998. return 0;
  999. }
  1000. EXPORT_SYMBOL(agp3_generic_fetch_size);
  1001. void agp3_generic_tlbflush(struct agp_memory *mem)
  1002. {
  1003. u32 ctrl;
  1004. pci_read_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, &ctrl);
  1005. pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, ctrl & ~AGPCTRL_GTLBEN);
  1006. pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, ctrl);
  1007. }
  1008. EXPORT_SYMBOL(agp3_generic_tlbflush);
  1009. int agp3_generic_configure(void)
  1010. {
  1011. u32 temp;
  1012. struct aper_size_info_16 *current_size;
  1013. current_size = A_SIZE_16(agp_bridge->current_size);
  1014. pci_read_config_dword(agp_bridge->dev, AGP_APBASE, &temp);
  1015. agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  1016. /* set aperture size */
  1017. pci_write_config_word(agp_bridge->dev, agp_bridge->capndx+AGPAPSIZE, current_size->size_value);
  1018. /* set gart pointer */
  1019. pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPGARTLO, agp_bridge->gatt_bus_addr);
  1020. /* enable aperture and GTLB */
  1021. pci_read_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, &temp);
  1022. pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, temp | AGPCTRL_APERENB | AGPCTRL_GTLBEN);
  1023. return 0;
  1024. }
  1025. EXPORT_SYMBOL(agp3_generic_configure);
  1026. void agp3_generic_cleanup(void)
  1027. {
  1028. u32 ctrl;
  1029. pci_read_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, &ctrl);
  1030. pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, ctrl & ~AGPCTRL_APERENB);
  1031. }
  1032. EXPORT_SYMBOL(agp3_generic_cleanup);
  1033. struct aper_size_info_16 agp3_generic_sizes[AGP_GENERIC_SIZES_ENTRIES] =
  1034. {
  1035. {4096, 1048576, 10,0x000},
  1036. {2048, 524288, 9, 0x800},
  1037. {1024, 262144, 8, 0xc00},
  1038. { 512, 131072, 7, 0xe00},
  1039. { 256, 65536, 6, 0xf00},
  1040. { 128, 32768, 5, 0xf20},
  1041. { 64, 16384, 4, 0xf30},
  1042. { 32, 8192, 3, 0xf38},
  1043. { 16, 4096, 2, 0xf3c},
  1044. { 8, 2048, 1, 0xf3e},
  1045. { 4, 1024, 0, 0xf3f}
  1046. };
  1047. EXPORT_SYMBOL(agp3_generic_sizes);