generic.c 36 KB

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