开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
agpgart_be.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：107k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

agpgart_be.c：源码内容
  1. /*
  2.  * AGPGART module version 0.99
  3.  * Copyright (C) 1999 Jeff Hartmann
  4.  * Copyright (C) 1999 Precision Insight, Inc.
  5.  * Copyright (C) 1999 Xi Graphics, Inc.
  6.  *
  7.  * Permission is hereby granted, free of charge, to any person obtaining a
  8.  * copy of this software and associated documentation files (the "Software"),
  9.  * to deal in the Software without restriction, including without limitation
  10.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11.  * and/or sell copies of the Software, and to permit persons to whom the
  12.  * Software is furnished to do so, subject to the following conditions:
  13.  *
  14.  * The above copyright notice and this permission notice shall be included
  15.  * in all copies or substantial portions of the Software.
  16.  *
  17.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20.  * JEFF HARTMANN, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, 
  21.  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 
  22.  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE 
  23.  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24.  *
  25.  */
  26. #include <linux/config.h>
  27. #include <linux/version.h>
  28. #include <linux/module.h>
  29. #include <linux/types.h>
  30. #include <linux/kernel.h>
  31. #include <linux/sched.h>
  32. #include <linux/mm.h>
  33. #include <linux/string.h>
  34. #include <linux/errno.h>
  35. #include <linux/slab.h>
  36. #include <linux/vmalloc.h>
  37. #include <linux/pci.h>
  38. #include <linux/init.h>
  39. #include <linux/pagemap.h>
  40. #include <linux/miscdevice.h>
  41. #include <linux/pm.h>
  42. #include <asm/system.h>
  43. #include <asm/uaccess.h>
  44. #include <asm/io.h>
  45. #include <asm/page.h>
  47. #include <linux/agp_backend.h>
  48. #include "agp.h"
  50. MODULE_AUTHOR("Jeff Hartmann <jhartmann@precisioninsight.com>");
  51. MODULE_PARM(agp_try_unsupported, "1i");
  52. MODULE_LICENSE("GPL and additional rights");
  53. EXPORT_SYMBOL(agp_free_memory);
  54. EXPORT_SYMBOL(agp_allocate_memory);
  55. EXPORT_SYMBOL(agp_copy_info);
  56. EXPORT_SYMBOL(agp_bind_memory);
  57. EXPORT_SYMBOL(agp_unbind_memory);
  58. EXPORT_SYMBOL(agp_enable);
  59. EXPORT_SYMBOL(agp_backend_acquire);
  60. EXPORT_SYMBOL(agp_backend_release);
  62. static void flush_cache(void);
  64. static struct agp_bridge_data agp_bridge;
  65. static int agp_try_unsupported __initdata = 0;
  68. static inline void flush_cache(void)
  69. {
  70. #if defined(__i386__) || defined(__x86_64__)
  71. asm volatile ("wbinvd":::"memory");
  72. #elif defined(__alpha__) || defined(__ia64__) || defined(__sparc__)
  73. /* ??? I wonder if we'll really need to flush caches, or if the
  74.    core logic can manage to keep the system coherent.  The ARM
  75.    speaks only of using `cflush' to get things in memory in
  76.    preparation for power failure.
  78.    If we do need to call `cflush', we'll need a target page,
  79.    as we can only flush one page at a time.
  81.    Ditto for IA-64. --davidm 00/08/07 */
  82. mb();
  83. #else
  84. #error "Please define flush_cache."
  85. #endif
  86. }
  88. #ifdef CONFIG_SMP
  89. static atomic_t cpus_waiting;
  91. static void ipi_handler(void *null)
  92. {
  93. flush_cache();
  94. atomic_dec(&cpus_waiting);
  95. while (atomic_read(&cpus_waiting) > 0)
  96. barrier();
  97. }
  99. static void smp_flush_cache(void)
  100. {
  101. atomic_set(&cpus_waiting, smp_num_cpus - 1);
  102. if (smp_call_function(ipi_handler, NULL, 1, 0) != 0)
  103. panic(PFX "timed out waiting for the other CPUs!n");
  104. flush_cache();
  105. while (atomic_read(&cpus_waiting) > 0)
  106. barrier();
  107. }
  108. #define global_cache_flush smp_flush_cache
  109. #else /* CONFIG_SMP */
  110. #define global_cache_flush flush_cache
  111. #endif /* CONFIG_SMP */
  113. int agp_backend_acquire(void)
  114. {
  115. if (agp_bridge.type == NOT_SUPPORTED) {
  116. return -EINVAL;
  117. }
  118. atomic_inc(&agp_bridge.agp_in_use);
  120. if (atomic_read(&agp_bridge.agp_in_use) != 1) {
  121. atomic_dec(&agp_bridge.agp_in_use);
  122. return -EBUSY;
  123. }
  124. MOD_INC_USE_COUNT;
  125. return 0;
  126. }
  128. void agp_backend_release(void)
  129. {
  130. if (agp_bridge.type == NOT_SUPPORTED) {
  131. return;
  132. }
  133. atomic_dec(&agp_bridge.agp_in_use);
  134. MOD_DEC_USE_COUNT;
  135. }
  137. /* 
  138.  * Generic routines for handling agp_memory structures -
  139.  * They use the basic page allocation routines to do the
  140.  * brunt of the work.
  141.  */
  144. static void agp_free_key(int key)
  145. {
  147. if (key < 0) {
  148. return;
  149. }
  150. if (key < MAXKEY) {
  151. clear_bit(key, agp_bridge.key_list);
  152. }
  153. }
  155. static int agp_get_key(void)
  156. {
  157. int bit;
  159. bit = find_first_zero_bit(agp_bridge.key_list, MAXKEY);
  160. if (bit < MAXKEY) {
  161. set_bit(bit, agp_bridge.key_list);
  162. return bit;
  163. }
  164. return -1;
  165. }
  167. static agp_memory *agp_create_memory(int scratch_pages)
  168. {
  169. agp_memory *new;
  171. new = kmalloc(sizeof(agp_memory), GFP_KERNEL);
  173. if (new == NULL) {
  174. return NULL;
  175. }
  176. memset(new, 0, sizeof(agp_memory));
  177. new->key = agp_get_key();
  179. if (new->key < 0) {
  180. kfree(new);
  181. return NULL;
  182. }
  183. new->memory = vmalloc(PAGE_SIZE * scratch_pages);
  185. if (new->memory == NULL) {
  186. agp_free_key(new->key);
  187. kfree(new);
  188. return NULL;
  189. }
  190. new->num_scratch_pages = scratch_pages;
  191. return new;
  192. }
  194. void agp_free_memory(agp_memory * curr)
  195. {
  196. int i;
  198. if ((agp_bridge.type == NOT_SUPPORTED) || (curr == NULL)) {
  199. return;
  200. }
  201. if (curr->is_bound == TRUE) {
  202. agp_unbind_memory(curr);
  203. }
  204. if (curr->type != 0) {
  205. agp_bridge.free_by_type(curr);
  206. return;
  207. }
  208. if (curr->page_count != 0) {
  209. for (i = 0; i < curr->page_count; i++) {
  210. curr->memory[i] &= ~(0x00000fff);
  211. agp_bridge.agp_destroy_page((unsigned long)
  212.  phys_to_virt(curr->memory[i]));
  213. }
  214. }
  215. agp_free_key(curr->key);
  216. vfree(curr->memory);
  217. kfree(curr);
  218. MOD_DEC_USE_COUNT;
  219. }
  221. #define ENTRIES_PER_PAGE (PAGE_SIZE / sizeof(unsigned long))
  223. agp_memory *agp_allocate_memory(size_t page_count, u32 type)
  224. {
  225. int scratch_pages;
  226. agp_memory *new;
  227. int i;
  229. if (agp_bridge.type == NOT_SUPPORTED) {
  230. return NULL;
  231. }
  232. if ((atomic_read(&agp_bridge.current_memory_agp) + page_count) >
  233.     agp_bridge.max_memory_agp) {
  234. return NULL;
  235. }
  237. if (type != 0) {
  238. new = agp_bridge.alloc_by_type(page_count, type);
  239. return new;
  240. }
  241.        /* We always increase the module count, since free auto-decrements
  242.  * it
  243.  */
  245.        MOD_INC_USE_COUNT;
  247. scratch_pages = (page_count + ENTRIES_PER_PAGE - 1) / ENTRIES_PER_PAGE;
  249. new = agp_create_memory(scratch_pages);
  251. if (new == NULL) {
  252.        MOD_DEC_USE_COUNT;
  253. return NULL;
  254. }
  255. for (i = 0; i < page_count; i++) {
  256. new->memory[i] = agp_bridge.agp_alloc_page();
  258. if (new->memory[i] == 0) {
  259. /* Free this structure */
  260. agp_free_memory(new);
  261. return NULL;
  262. }
  263. new->memory[i] =
  264.     agp_bridge.mask_memory(
  265.    virt_to_phys((void *) new->memory[i]),
  266.   type);
  267. new->page_count++;
  268. }
  270. return new;
  271. }
  273. /* End - Generic routines for handling agp_memory structures */
  275. static int agp_return_size(void)
  276. {
  277. int current_size;
  278. void *temp;
  280. temp = agp_bridge.current_size;
  282. switch (agp_bridge.size_type) {
  283. case U8_APER_SIZE:
  284. current_size = A_SIZE_8(temp)->size;
  285. break;
  286. case U16_APER_SIZE:
  287. current_size = A_SIZE_16(temp)->size;
  288. break;
  289. case U32_APER_SIZE:
  290. current_size = A_SIZE_32(temp)->size;
  291. break;
  292. case LVL2_APER_SIZE:
  293. current_size = A_SIZE_LVL2(temp)->size;
  294. break;
  295. case FIXED_APER_SIZE:
  296. current_size = A_SIZE_FIX(temp)->size;
  297. break;
  298. default:
  299. current_size = 0;
  300. break;
  301. }
  303. return current_size;
  304. }
  306. /* Routine to copy over information structure */
  308. void agp_copy_info(agp_kern_info * info)
  309. {
  310. unsigned long page_mask = 0;
  311. int i;
  313. memset(info, 0, sizeof(agp_kern_info));
  314. if (agp_bridge.type == NOT_SUPPORTED) {
  315. info->chipset = agp_bridge.type;
  316. return;
  317. }
  318. info->version.major = agp_bridge.version->major;
  319. info->version.minor = agp_bridge.version->minor;
  320. info->device = agp_bridge.dev;
  321. info->chipset = agp_bridge.type;
  322. info->mode = agp_bridge.mode;
  323. info->aper_base = agp_bridge.gart_bus_addr;
  324. info->aper_size = agp_return_size();
  325. info->max_memory = agp_bridge.max_memory_agp;
  326. info->current_memory = atomic_read(&agp_bridge.current_memory_agp);
  327. info->cant_use_aperture = agp_bridge.cant_use_aperture;
  329. for(i = 0; i < agp_bridge.num_of_masks; i++)
  330. page_mask |= agp_bridge.mask_memory(page_mask, i);
  332. info->page_mask = ~page_mask;
  333. }
  335. /* End - Routine to copy over information structure */
  337. /*
  338.  * Routines for handling swapping of agp_memory into the GATT -
  339.  * These routines take agp_memory and insert them into the GATT.
  340.  * They call device specific routines to actually write to the GATT.
  341.  */
  343. int agp_bind_memory(agp_memory * curr, off_t pg_start)
  344. {
  345. int ret_val;
  347. if ((agp_bridge.type == NOT_SUPPORTED) ||
  348.     (curr == NULL) || (curr->is_bound == TRUE)) {
  349. return -EINVAL;
  350. }
  351. if (curr->is_flushed == FALSE) {
  352. CACHE_FLUSH();
  353. curr->is_flushed = TRUE;
  354. }
  355. ret_val = agp_bridge.insert_memory(curr, pg_start, curr->type);
  357. if (ret_val != 0) {
  358. return ret_val;
  359. }
  360. curr->is_bound = TRUE;
  361. curr->pg_start = pg_start;
  362. return 0;
  363. }
  365. int agp_unbind_memory(agp_memory * curr)
  366. {
  367. int ret_val;
  369. if ((agp_bridge.type == NOT_SUPPORTED) || (curr == NULL)) {
  370. return -EINVAL;
  371. }
  372. if (curr->is_bound != TRUE) {
  373. return -EINVAL;
  374. }
  375. ret_val = agp_bridge.remove_memory(curr, curr->pg_start, curr->type);
  377. if (ret_val != 0) {
  378. return ret_val;
  379. }
  380. curr->is_bound = FALSE;
  381. curr->pg_start = 0;
  382. return 0;
  383. }
  385. /* End - Routines for handling swapping of agp_memory into the GATT */
  387. /* 
  388.  * Driver routines - start
  389.  * Currently this module supports the following chipsets:
  390.  * i810, i815, 440lx, 440bx, 440gx, i830, i840, i845, i850, i860, via vp3,
  391.  * via mvp3, via kx133, via kt133, amd irongate, amd 761, amd 762, ALi M1541,
  392.  * and generic support for the SiS chipsets.
  393.  */
  395. /* Generic Agp routines - Start */
  397. static void agp_generic_agp_enable(u32 mode)
  398. {
  399. struct pci_dev *device = NULL;
  400. u32 command, scratch, cap_id;
  401. u8 cap_ptr;
  403. pci_read_config_dword(agp_bridge.dev,
  404.       agp_bridge.capndx + 4,
  405.       &command);
  407. /*
  408.  * PASS1: go throu all devices that claim to be
  409.  *        AGP devices and collect their data.
  410.  */
  413. pci_for_each_dev(device)
  414. {
  415. /*
  416.  * Enable AGP devices. Most will be VGA display but
  417.  * some may be coprocessors on non VGA devices too
  418.  */
  419.  
  420. if((((device->class >> 16) & 0xFF) != PCI_BASE_CLASS_DISPLAY) &&
  421. (device->class != (PCI_CLASS_PROCESSOR_CO << 8)))
  422. continue;
  424. pci_read_config_dword(device, 0x04, &scratch);
  426. if (!(scratch & 0x00100000))
  427. continue;
  429. pci_read_config_byte(device, 0x34, &cap_ptr);
  431. if (cap_ptr != 0x00) {
  432. do {
  433. pci_read_config_dword(device,
  434.       cap_ptr, &cap_id);
  436. if ((cap_id & 0xff) != 0x02)
  437. cap_ptr = (cap_id >> 8) & 0xff;
  438. }
  439. while (((cap_id & 0xff) != 0x02) && (cap_ptr != 0x00));
  440. }
  441. if (cap_ptr != 0x00) {
  442. /*
  443.  * Ok, here we have a AGP device. Disable impossible 
  444.  * settings, and adjust the readqueue to the minimum.
  445.  */
  447. pci_read_config_dword(device, cap_ptr + 4, &scratch);
  449. /* adjust RQ depth */
  450. command =
  451.     ((command & ~0xff000000) |
  452.      min_t(u32, (mode & 0xff000000),
  453.  min_t(u32, (command & 0xff000000),
  454.      (scratch & 0xff000000))));
  456. /* disable SBA if it's not supported */
  457. if (!((command & 0x00000200) &&
  458.       (scratch & 0x00000200) &&
  459.       (mode & 0x00000200)))
  460. command &= ~0x00000200;
  462. /* disable FW if it's not supported */
  463. if (!((command & 0x00000010) &&
  464.       (scratch & 0x00000010) &&
  465.       (mode & 0x00000010)))
  466. command &= ~0x00000010;
  468. if (!((command & 4) &&
  469.       (scratch & 4) &&
  470.       (mode & 4)))
  471. command &= ~0x00000004;
  473. if (!((command & 2) &&
  474.       (scratch & 2) &&
  475.       (mode & 2)))
  476. command &= ~0x00000002;
  478. if (!((command & 1) &&
  479.       (scratch & 1) &&
  480.       (mode & 1)))
  481. command &= ~0x00000001;
  482. }
  483. }
  484. /*
  485.  * PASS2: Figure out the 4X/2X/1X setting and enable the
  486.  *        target (our motherboard chipset).
  487.  */
  489. if (command & 4) {
  490. command &= ~3; /* 4X */
  491. }
  492. if (command & 2) {
  493. command &= ~5; /* 2X */
  494. }
  495. if (command & 1) {
  496. command &= ~6; /* 1X */
  497. }
  498. command |= 0x00000100;
  500. pci_write_config_dword(agp_bridge.dev,
  501.        agp_bridge.capndx + 8,
  502.        command);
  504. /*
  505.  * PASS3: Go throu all AGP devices and update the
  506.  *        command registers.
  507.  */
  509. while ((device = pci_find_class(PCI_CLASS_DISPLAY_VGA << 8,
  510. device)) != NULL) {
  511. pci_read_config_dword(device, 0x04, &scratch);
  513. if (!(scratch & 0x00100000))
  514. continue;
  516. pci_read_config_byte(device, 0x34, &cap_ptr);
  518. if (cap_ptr != 0x00) {
  519. do {
  520. pci_read_config_dword(device,
  521.       cap_ptr, &cap_id);
  523. if ((cap_id & 0xff) != 0x02)
  524. cap_ptr = (cap_id >> 8) & 0xff;
  525. }
  526. while (((cap_id & 0xff) != 0x02) && (cap_ptr != 0x00));
  527. }
  528. if (cap_ptr != 0x00)
  529. pci_write_config_dword(device, cap_ptr + 8, command);
  530. }
  531. }
  533. static int agp_generic_create_gatt_table(void)
  534. {
  535. char *table;
  536. char *table_end;
  537. int size;
  538. int page_order;
  539. int num_entries;
  540. int i;
  541. void *temp;
  542. struct page *page;
  544. /* The generic routines can't handle 2 level gatt's */
  545. if (agp_bridge.size_type == LVL2_APER_SIZE) {
  546. return -EINVAL;
  547. }
  549. table = NULL;
  550. i = agp_bridge.aperture_size_idx;
  551. temp = agp_bridge.current_size;
  552. size = page_order = num_entries = 0;
  554. if (agp_bridge.size_type != FIXED_APER_SIZE) {
  555. do {
  556. switch (agp_bridge.size_type) {
  557. case U8_APER_SIZE:
  558. size = A_SIZE_8(temp)->size;
  559. page_order =
  560.     A_SIZE_8(temp)->page_order;
  561. num_entries =
  562.     A_SIZE_8(temp)->num_entries;
  563. break;
  564. case U16_APER_SIZE:
  565. size = A_SIZE_16(temp)->size;
  566. page_order = A_SIZE_16(temp)->page_order;
  567. num_entries = A_SIZE_16(temp)->num_entries;
  568. break;
  569. case U32_APER_SIZE:
  570. size = A_SIZE_32(temp)->size;
  571. page_order = A_SIZE_32(temp)->page_order;
  572. num_entries = A_SIZE_32(temp)->num_entries;
  573. break;
  574. /* This case will never really happen. */
  575. case FIXED_APER_SIZE:
  576. case LVL2_APER_SIZE:
  577. default:
  578. size = page_order = num_entries = 0;
  579. break;
  580. }
  582. table = (char *) __get_free_pages(GFP_KERNEL,
  583.   page_order);
  585. if (table == NULL) {
  586. i++;
  587. switch (agp_bridge.size_type) {
  588. case U8_APER_SIZE:
  589. agp_bridge.current_size = A_IDX8();
  590. break;
  591. case U16_APER_SIZE:
  592. agp_bridge.current_size = A_IDX16();
  593. break;
  594. case U32_APER_SIZE:
  595. agp_bridge.current_size = A_IDX32();
  596. break;
  597. /* This case will never really 
  598.  * happen. 
  599.  */
  600. case FIXED_APER_SIZE:
  601. case LVL2_APER_SIZE:
  602. default:
  603. agp_bridge.current_size =
  604.     agp_bridge.current_size;
  605. break;
  606. }
  607. } else {
  608. agp_bridge.aperture_size_idx = i;
  609. }
  610. } while ((table == NULL) &&
  611.  (i < agp_bridge.num_aperture_sizes));
  612. } else {
  613. size = ((aper_size_info_fixed *) temp)->size;
  614. page_order = ((aper_size_info_fixed *) temp)->page_order;
  615. num_entries = ((aper_size_info_fixed *) temp)->num_entries;
  616. table = (char *) __get_free_pages(GFP_KERNEL, page_order);
  617. }
  619. if (table == NULL) {
  620. return -ENOMEM;
  621. }
  622. table_end = table + ((PAGE_SIZE * (1 << page_order)) - 1);
  624. for (page = virt_to_page(table); page <= virt_to_page(table_end); page++)
  625. set_bit(PG_reserved, &page->flags);
  627. agp_bridge.gatt_table_real = (unsigned long *) table;
  628. CACHE_FLUSH();
  629. agp_bridge.gatt_table = ioremap_nocache(virt_to_phys(table),
  630. (PAGE_SIZE * (1 << page_order)));
  631. CACHE_FLUSH();
  633. if (agp_bridge.gatt_table == NULL) {
  634. for (page = virt_to_page(table); page <= virt_to_page(table_end); page++)
  635. clear_bit(PG_reserved, &page->flags);
  637. free_pages((unsigned long) table, page_order);
  639. return -ENOMEM;
  640. }
  641. agp_bridge.gatt_bus_addr = virt_to_phys(agp_bridge.gatt_table_real);
  643. for (i = 0; i < num_entries; i++) {
  644. agp_bridge.gatt_table[i] =
  645.     (unsigned long) agp_bridge.scratch_page;
  646. }
  648. return 0;
  649. }
  651. static int agp_generic_suspend(void)
  652. {
  653. return 0;
  654. }
  656. static void agp_generic_resume(void)
  657. {
  658. return;
  659. }
  661. static int agp_generic_free_gatt_table(void)
  662. {
  663. int page_order;
  664. char *table, *table_end;
  665. void *temp;
  666. struct page *page;
  668. temp = agp_bridge.current_size;
  670. switch (agp_bridge.size_type) {
  671. case U8_APER_SIZE:
  672. page_order = A_SIZE_8(temp)->page_order;
  673. break;
  674. case U16_APER_SIZE:
  675. page_order = A_SIZE_16(temp)->page_order;
  676. break;
  677. case U32_APER_SIZE:
  678. page_order = A_SIZE_32(temp)->page_order;
  679. break;
  680. case FIXED_APER_SIZE:
  681. page_order = A_SIZE_FIX(temp)->page_order;
  682. break;
  683. case LVL2_APER_SIZE:
  684. /* The generic routines can't deal with 2 level gatt's */
  685. return -EINVAL;
  686. break;
  687. default:
  688. page_order = 0;
  689. break;
  690. }
  692. /* Do not worry about freeing memory, because if this is
  693.  * called, then all agp memory is deallocated and removed
  694.  * from the table.
  695.  */
  697. iounmap(agp_bridge.gatt_table);
  698. table = (char *) agp_bridge.gatt_table_real;
  699. table_end = table + ((PAGE_SIZE * (1 << page_order)) - 1);
  701. for (page = virt_to_page(table); page <= virt_to_page(table_end); page++)
  702. clear_bit(PG_reserved, &page->flags);
  704. free_pages((unsigned long) agp_bridge.gatt_table_real, page_order);
  705. return 0;
  706. }
  708. static int agp_generic_insert_memory(agp_memory * mem,
  709.      off_t pg_start, int type)
  710. {
  711. int i, j, num_entries;
  712. void *temp;
  714. temp = agp_bridge.current_size;
  716. switch (agp_bridge.size_type) {
  717. case U8_APER_SIZE:
  718. num_entries = A_SIZE_8(temp)->num_entries;
  719. break;
  720. case U16_APER_SIZE:
  721. num_entries = A_SIZE_16(temp)->num_entries;
  722. break;
  723. case U32_APER_SIZE:
  724. num_entries = A_SIZE_32(temp)->num_entries;
  725. break;
  726. case FIXED_APER_SIZE:
  727. num_entries = A_SIZE_FIX(temp)->num_entries;
  728. break;
  729. case LVL2_APER_SIZE:
  730. /* The generic routines can't deal with 2 level gatt's */
  731. return -EINVAL;
  732. break;
  733. default:
  734. num_entries = 0;
  735. break;
  736. }
  738. if (type != 0 || mem->type != 0) {
  739. /* The generic routines know nothing of memory types */
  740. return -EINVAL;
  741. }
  742. if ((pg_start + mem->page_count) > num_entries) {
  743. return -EINVAL;
  744. }
  745. j = pg_start;
  747. while (j < (pg_start + mem->page_count)) {
  748. if (!PGE_EMPTY(agp_bridge.gatt_table[j])) {
  749. return -EBUSY;
  750. }
  751. j++;
  752. }
  754. if (mem->is_flushed == FALSE) {
  755. CACHE_FLUSH();
  756. mem->is_flushed = TRUE;
  757. }
  758. for (i = 0, j = pg_start; i < mem->page_count; i++, j++) {
  759. agp_bridge.gatt_table[j] = mem->memory[i];
  760. }
  762. agp_bridge.tlb_flush(mem);
  763. return 0;
  764. }
  766. static int agp_generic_remove_memory(agp_memory * mem, off_t pg_start,
  767.      int type)
  768. {
  769. int i;
  771. if (type != 0 || mem->type != 0) {
  772. /* The generic routines know nothing of memory types */
  773. return -EINVAL;
  774. }
  775. for (i = pg_start; i < (mem->page_count + pg_start); i++) {
  776. agp_bridge.gatt_table[i] =
  777.     (unsigned long) agp_bridge.scratch_page;
  778. }
  780. agp_bridge.tlb_flush(mem);
  781. return 0;
  782. }
  784. static agp_memory *agp_generic_alloc_by_type(size_t page_count, int type)
  785. {
  786. return NULL;
  787. }
  789. static void agp_generic_free_by_type(agp_memory * curr)
  790. {
  791. if (curr->memory != NULL) {
  792. vfree(curr->memory);
  793. }
  794. agp_free_key(curr->key);
  795. kfree(curr);
  796. }
  798. /* 
  799.  * Basic Page Allocation Routines -
  800.  * These routines handle page allocation
  801.  * and by default they reserve the allocated 
  802.  * memory.  They also handle incrementing the
  803.  * current_memory_agp value, Which is checked
  804.  * against a maximum value.
  805.  */
  807. static unsigned long agp_generic_alloc_page(void)
  808. {
  809. struct page * page;
  811. page = alloc_page(GFP_KERNEL);
  812. if (page == NULL) {
  813. return 0;
  814. }
  815. atomic_inc(&page->count);
  816. set_bit(PG_locked, &page->flags);
  817. atomic_inc(&agp_bridge.current_memory_agp);
  818. return (unsigned long)page_address(page);
  819. }
  821. static void agp_generic_destroy_page(unsigned long addr)
  822. {
  823. void *pt = (void *) addr;
  824. struct page *page;
  826. if (pt == NULL) {
  827. return;
  828. }
  830. page = virt_to_page(pt);
  831. atomic_dec(&page->count);
  832. clear_bit(PG_locked, &page->flags);
  833. wake_up(&page->wait);
  834. free_page((unsigned long) pt);
  835. atomic_dec(&agp_bridge.current_memory_agp);
  836. }
  838. /* End Basic Page Allocation Routines */
  840. void agp_enable(u32 mode)
  841. {
  842. if (agp_bridge.type == NOT_SUPPORTED) return;
  843. agp_bridge.agp_enable(mode);
  844. }
  846. /* End - Generic Agp routines */
  848. #ifdef CONFIG_AGP_I810
  849. static aper_size_info_fixed intel_i810_sizes[] =
  850. {
  851. {64, 16384, 4},
  852.      /* The 32M mode still requires a 64k gatt */
  853. {32, 8192, 4}
  854. };
  856. #define AGP_DCACHE_MEMORY 1
  857. #define AGP_PHYS_MEMORY   2
  859. static gatt_mask intel_i810_masks[] =
  860. {
  861. {I810_PTE_VALID, 0},
  862. {(I810_PTE_VALID | I810_PTE_LOCAL), AGP_DCACHE_MEMORY},
  863. {I810_PTE_VALID, 0}
  864. };
  866. static struct _intel_i810_private {
  867. struct pci_dev *i810_dev; /* device one */
  868. volatile u8 *registers;
  869. int num_dcache_entries;
  870. } intel_i810_private;
  872. static int intel_i810_fetch_size(void)
  873. {
  874. u32 smram_miscc;
  875. aper_size_info_fixed *values;
  877. pci_read_config_dword(agp_bridge.dev, I810_SMRAM_MISCC, &smram_miscc);
  878. values = A_SIZE_FIX(agp_bridge.aperture_sizes);
  880. if ((smram_miscc & I810_GMS) == I810_GMS_DISABLE) {
  881. printk(KERN_WARNING PFX "i810 is disabledn");
  882. return 0;
  883. }
  884. if ((smram_miscc & I810_GFX_MEM_WIN_SIZE) == I810_GFX_MEM_WIN_32M) {
  885. agp_bridge.previous_size =
  886.     agp_bridge.current_size = (void *) (values + 1);
  887. agp_bridge.aperture_size_idx = 1;
  888. return values[1].size;
  889. } else {
  890. agp_bridge.previous_size =
  891.     agp_bridge.current_size = (void *) (values);
  892. agp_bridge.aperture_size_idx = 0;
  893. return values[0].size;
  894. }
  896. return 0;
  897. }
  899. static int intel_i810_configure(void)
  900. {
  901. aper_size_info_fixed *current_size;
  902. u32 temp;
  903. int i;
  905. current_size = A_SIZE_FIX(agp_bridge.current_size);
  907. pci_read_config_dword(intel_i810_private.i810_dev, I810_MMADDR, &temp);
  908. temp &= 0xfff80000;
  910. intel_i810_private.registers =
  911.     (volatile u8 *) ioremap(temp, 128 * 4096);
  913. if ((INREG32(intel_i810_private.registers, I810_DRAM_CTL)
  914.      & I810_DRAM_ROW_0) == I810_DRAM_ROW_0_SDRAM) {
  915. /* This will need to be dynamically assigned */
  916. printk(KERN_INFO PFX "detected 4MB dedicated video ram.n");
  917. intel_i810_private.num_dcache_entries = 1024;
  918. }
  919. pci_read_config_dword(intel_i810_private.i810_dev, I810_GMADDR, &temp);
  920. agp_bridge.gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  921. OUTREG32(intel_i810_private.registers, I810_PGETBL_CTL,
  922.  agp_bridge.gatt_bus_addr | I810_PGETBL_ENABLED);
  923. CACHE_FLUSH();
  925. if (agp_bridge.needs_scratch_page == TRUE) {
  926. for (i = 0; i < current_size->num_entries; i++) {
  927. OUTREG32(intel_i810_private.registers,
  928.  I810_PTE_BASE + (i * 4),
  929.  agp_bridge.scratch_page);
  930. }
  931. }
  932. return 0;
  933. }
  935. static void intel_i810_cleanup(void)
  936. {
  937. OUTREG32(intel_i810_private.registers, I810_PGETBL_CTL, 0);
  938. iounmap((void *) intel_i810_private.registers);
  939. }
  941. static void intel_i810_tlbflush(agp_memory * mem)
  942. {
  943. return;
  944. }
  946. static void intel_i810_agp_enable(u32 mode)
  947. {
  948. return;
  949. }
  951. static int intel_i810_insert_entries(agp_memory * mem, off_t pg_start,
  952.      int type)
  953. {
  954. int i, j, num_entries;
  955. void *temp;
  957. temp = agp_bridge.current_size;
  958. num_entries = A_SIZE_FIX(temp)->num_entries;
  960. if ((pg_start + mem->page_count) > num_entries) {
  961. return -EINVAL;
  962. }
  963. for (j = pg_start; j < (pg_start + mem->page_count); j++) {
  964. if (!PGE_EMPTY(agp_bridge.gatt_table[j])) {
  965. return -EBUSY;
  966. }
  967. }
  969. if (type != 0 || mem->type != 0) {
  970. if ((type == AGP_DCACHE_MEMORY) &&
  971.     (mem->type == AGP_DCACHE_MEMORY)) {
  972. /* special insert */
  973. CACHE_FLUSH();
  974. for (i = pg_start;
  975.      i < (pg_start + mem->page_count); i++) {
  976. OUTREG32(intel_i810_private.registers,
  977.  I810_PTE_BASE + (i * 4),
  978.  (i * 4096) | I810_PTE_LOCAL |
  979.  I810_PTE_VALID);
  980. }
  981. CACHE_FLUSH();
  982. agp_bridge.tlb_flush(mem);
  983. return 0;
  984. }
  985.         if((type == AGP_PHYS_MEMORY) &&
  986.    (mem->type == AGP_PHYS_MEMORY)) {
  987.    goto insert;
  988. }
  989. return -EINVAL;
  990. }
  992. insert:
  993.     CACHE_FLUSH();
  994. for (i = 0, j = pg_start; i < mem->page_count; i++, j++) {
  995. OUTREG32(intel_i810_private.registers,
  996.  I810_PTE_BASE + (j * 4), mem->memory[i]);
  997. }
  998. CACHE_FLUSH();
  1000. agp_bridge.tlb_flush(mem);
  1001. return 0;
  1002. }
  1004. static int intel_i810_remove_entries(agp_memory * mem, off_t pg_start,
  1005.      int type)
  1006. {
  1007. int i;
  1009. for (i = pg_start; i < (mem->page_count + pg_start); i++) {
  1010. OUTREG32(intel_i810_private.registers,
  1011.  I810_PTE_BASE + (i * 4),
  1012.  agp_bridge.scratch_page);
  1013. }
  1015. CACHE_FLUSH();
  1016. agp_bridge.tlb_flush(mem);
  1017. return 0;
  1018. }
  1020. static agp_memory *intel_i810_alloc_by_type(size_t pg_count, int type)
  1021. {
  1022. agp_memory *new;
  1024. if (type == AGP_DCACHE_MEMORY) {
  1025. if (pg_count != intel_i810_private.num_dcache_entries) {
  1026. return NULL;
  1027. }
  1028. new = agp_create_memory(1);
  1030. if (new == NULL) {
  1031. return NULL;
  1032. }
  1033. new->type = AGP_DCACHE_MEMORY;
  1034. new->page_count = pg_count;
  1035. new->num_scratch_pages = 0;
  1036. vfree(new->memory);
  1037.     MOD_INC_USE_COUNT;
  1038. return new;
  1039. }
  1040. if(type == AGP_PHYS_MEMORY) {
  1041. /* The I810 requires a physical address to program
  1042.  * it's mouse pointer into hardware.  However the
  1043.  * Xserver still writes to it through the agp
  1044.  * aperture
  1045.  */
  1046.     if (pg_count != 1) {
  1047.     return NULL;
  1048. }
  1049.     new = agp_create_memory(1);
  1051. if (new == NULL) {
  1052. return NULL;
  1053. }
  1054.     MOD_INC_USE_COUNT;
  1055. new->memory[0] = agp_bridge.agp_alloc_page();
  1057. if (new->memory[0] == 0) {
  1058. /* Free this structure */
  1059. agp_free_memory(new);
  1060. return NULL;
  1061. }
  1062. new->memory[0] =
  1063.     agp_bridge.mask_memory(
  1064.    virt_to_phys((void *) new->memory[0]),
  1065.   type);
  1066. new->page_count = 1;
  1067.     new->num_scratch_pages = 1;
  1068.     new->type = AGP_PHYS_MEMORY;
  1069.         new->physical = virt_to_phys((void *) new->memory[0]);
  1070.     return new;
  1071. }
  1072.    
  1073. return NULL;
  1074. }
  1076. static void intel_i810_free_by_type(agp_memory * curr)
  1077. {
  1078. agp_free_key(curr->key);
  1079.     if(curr->type == AGP_PHYS_MEMORY) {
  1080.     agp_bridge.agp_destroy_page((unsigned long)
  1081.  phys_to_virt(curr->memory[0]));
  1082. vfree(curr->memory);
  1083. }
  1084. kfree(curr);
  1085.     MOD_DEC_USE_COUNT;
  1086. }
  1088. static unsigned long intel_i810_mask_memory(unsigned long addr, int type)
  1089. {
  1090. /* Type checking must be done elsewhere */
  1091. return addr | agp_bridge.masks[type].mask;
  1092. }
  1094. static int __init intel_i810_setup(struct pci_dev *i810_dev)
  1095. {
  1096. intel_i810_private.i810_dev = i810_dev;
  1098. agp_bridge.masks = intel_i810_masks;
  1099. agp_bridge.num_of_masks = 2;
  1100. agp_bridge.aperture_sizes = (void *) intel_i810_sizes;
  1101. agp_bridge.size_type = FIXED_APER_SIZE;
  1102. agp_bridge.num_aperture_sizes = 2;
  1103. agp_bridge.dev_private_data = (void *) &intel_i810_private;
  1104. agp_bridge.needs_scratch_page = TRUE;
  1105. agp_bridge.configure = intel_i810_configure;
  1106. agp_bridge.fetch_size = intel_i810_fetch_size;
  1107. agp_bridge.cleanup = intel_i810_cleanup;
  1108. agp_bridge.tlb_flush = intel_i810_tlbflush;
  1109. agp_bridge.mask_memory = intel_i810_mask_memory;
  1110. agp_bridge.agp_enable = intel_i810_agp_enable;
  1111. agp_bridge.cache_flush = global_cache_flush;
  1112. agp_bridge.create_gatt_table = agp_generic_create_gatt_table;
  1113. agp_bridge.free_gatt_table = agp_generic_free_gatt_table;
  1114. agp_bridge.insert_memory = intel_i810_insert_entries;
  1115. agp_bridge.remove_memory = intel_i810_remove_entries;
  1116. agp_bridge.alloc_by_type = intel_i810_alloc_by_type;
  1117. agp_bridge.free_by_type = intel_i810_free_by_type;
  1118. agp_bridge.agp_alloc_page = agp_generic_alloc_page;
  1119. agp_bridge.agp_destroy_page = agp_generic_destroy_page;
  1120. agp_bridge.suspend = agp_generic_suspend;
  1121. agp_bridge.resume = agp_generic_resume;
  1122. agp_bridge.cant_use_aperture = 0;
  1124. return 0;
  1125. }
  1127. static aper_size_info_fixed intel_i830_sizes[] =
  1128. {
  1129. {128, 32768, 5},
  1130. /* The 64M mode still requires a 128k gatt */
  1131. {64, 16384, 5}
  1132. };
  1134. static struct _intel_i830_private {
  1135. struct pci_dev *i830_dev;   /* device one */
  1136. volatile u8 *registers;
  1137. int gtt_entries;
  1138. } intel_i830_private;
  1140. static void intel_i830_init_gtt_entries(void) {
  1141. u16 gmch_ctrl;
  1142. int gtt_entries;
  1143. u8 rdct;
  1144. static const int ddt[4] = { 0, 16, 32, 64 };
  1146. pci_read_config_word(agp_bridge.dev,I830_GMCH_CTRL,&gmch_ctrl);
  1148. switch (gmch_ctrl & I830_GMCH_GMS_MASK) {
  1149. case I830_GMCH_GMS_STOLEN_512:
  1150. gtt_entries = KB(512);
  1151. printk(KERN_INFO PFX "detected %dK stolen memory.n",gtt_entries / KB(1));
  1152. break;
  1153. case I830_GMCH_GMS_STOLEN_1024:
  1154. gtt_entries = MB(1);
  1155. printk(KERN_INFO PFX "detected %dK stolen memory.n",gtt_entries / KB(1));
  1156. break;
  1157. case I830_GMCH_GMS_STOLEN_8192:
  1158. gtt_entries = MB(8);
  1159. printk(KERN_INFO PFX "detected %dK stolen memory.n",gtt_entries / KB(1));
  1160. break;
  1161. case I830_GMCH_GMS_LOCAL:
  1162. rdct = INREG8(intel_i830_private.registers,I830_RDRAM_CHANNEL_TYPE);
  1163. gtt_entries = (I830_RDRAM_ND(rdct) + 1) * MB(ddt[I830_RDRAM_DDT(rdct)]);
  1164. printk(KERN_INFO PFX "detected %dK local memory.n",gtt_entries / KB(1));
  1165. break;
  1166. default:
  1167. printk(KERN_INFO PFX "no video memory detected.n");
  1168. gtt_entries = 0;
  1169. break;
  1170. }
  1172. gtt_entries /= KB(4);
  1174. intel_i830_private.gtt_entries = gtt_entries;
  1175. }
  1177. /* The intel i830 automatically initializes the agp aperture during POST.
  1178.  * Use the memory already set aside for in the GTT.
  1179.  */
  1180. static int intel_i830_create_gatt_table(void)
  1181. {
  1182. int page_order;
  1183. aper_size_info_fixed *size;
  1184. int num_entries;
  1185. u32 temp;
  1187. size = agp_bridge.current_size;
  1188. page_order = size->page_order;
  1189. num_entries = size->num_entries;
  1190. agp_bridge.gatt_table_real = 0;
  1192. pci_read_config_dword(intel_i830_private.i830_dev,I810_MMADDR,&temp);
  1193. temp &= 0xfff80000;
  1195. intel_i830_private.registers = (volatile u8 *) ioremap(temp,128 * 4096);
  1196. if (!intel_i830_private.registers) return (-ENOMEM);
  1198. temp = INREG32(intel_i830_private.registers,I810_PGETBL_CTL) & 0xfffff000;
  1199. CACHE_FLUSH();
  1201. /* we have to call this as early as possible after the MMIO base address is known */
  1202. intel_i830_init_gtt_entries();
  1204. agp_bridge.gatt_table = NULL;
  1206. agp_bridge.gatt_bus_addr = temp;
  1208. return(0);
  1209. }
  1211. /* Return the gatt table to a sane state. Use the top of stolen
  1212.  * memory for the GTT.
  1213.  */
  1214. static int intel_i830_free_gatt_table(void)
  1215. {
  1216. return(0);
  1217. }
  1219. static int intel_i830_fetch_size(void)
  1220. {
  1221. u16 gmch_ctrl;
  1222. aper_size_info_fixed *values;
  1224. pci_read_config_word(agp_bridge.dev,I830_GMCH_CTRL,&gmch_ctrl);
  1225. values = A_SIZE_FIX(agp_bridge.aperture_sizes);
  1227. if ((gmch_ctrl & I830_GMCH_MEM_MASK) == I830_GMCH_MEM_128M) {
  1228. agp_bridge.previous_size = agp_bridge.current_size = (void *) values;
  1229. agp_bridge.aperture_size_idx = 0;
  1230. return(values[0].size);
  1231. } else {
  1232. agp_bridge.previous_size = agp_bridge.current_size = (void *) values;
  1233. agp_bridge.aperture_size_idx = 1;
  1234. return(values[1].size);
  1235. }
  1237. return(0);
  1238. }
  1240. static int intel_i830_configure(void)
  1241. {
  1242. aper_size_info_fixed *current_size;
  1243. u32 temp;
  1244. u16 gmch_ctrl;
  1245. int i;
  1247. current_size = A_SIZE_FIX(agp_bridge.current_size);
  1249. pci_read_config_dword(intel_i830_private.i830_dev,I810_GMADDR,&temp);
  1250. agp_bridge.gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  1252. pci_read_config_word(agp_bridge.dev,I830_GMCH_CTRL,&gmch_ctrl);
  1253. gmch_ctrl |= I830_GMCH_ENABLED;
  1254. pci_write_config_word(agp_bridge.dev,I830_GMCH_CTRL,gmch_ctrl);
  1256. OUTREG32(intel_i830_private.registers,I810_PGETBL_CTL,agp_bridge.gatt_bus_addr | I810_PGETBL_ENABLED);
  1257. CACHE_FLUSH();
  1259. if (agp_bridge.needs_scratch_page == TRUE)
  1260. for (i = intel_i830_private.gtt_entries; i < current_size->num_entries; i++)
  1261. OUTREG32(intel_i830_private.registers,I810_PTE_BASE + (i * 4),agp_bridge.scratch_page);
  1263. return (0);
  1264. }
  1266. static void intel_i830_cleanup(void)
  1267. {
  1268. iounmap((void *) intel_i830_private.registers);
  1269. }
  1271. static int intel_i830_insert_entries(agp_memory *mem,off_t pg_start,int type)
  1272. {
  1273. int i,j,num_entries;
  1274. void *temp;
  1276. temp = agp_bridge.current_size;
  1277. num_entries = A_SIZE_FIX(temp)->num_entries;
  1279. if (pg_start < intel_i830_private.gtt_entries) {
  1280. printk (KERN_DEBUG "pg_start == 0x%.8lx,intel_i830_private.gtt_entries == 0x%.8xn",
  1281. pg_start,intel_i830_private.gtt_entries);
  1283. printk ("Trying to insert into local/stolen memoryn");
  1284. return (-EINVAL);
  1285. }
  1287. if ((pg_start + mem->page_count) > num_entries)
  1288. return (-EINVAL);
  1290. /* The i830 can't check the GTT for entries since its read only,
  1291.  * depend on the caller to make the correct offset decisions.
  1292.  */
  1294. if ((type != 0 && type != AGP_PHYS_MEMORY) ||
  1295. (mem->type != 0 && mem->type != AGP_PHYS_MEMORY))
  1296. return (-EINVAL);
  1298. CACHE_FLUSH();
  1300. for (i = 0, j = pg_start; i < mem->page_count; i++, j++)
  1301. OUTREG32(intel_i830_private.registers,I810_PTE_BASE + (j * 4),mem->memory[i]);
  1303. CACHE_FLUSH();
  1305. agp_bridge.tlb_flush(mem);
  1307. return(0);
  1308. }
  1310. static int intel_i830_remove_entries(agp_memory *mem,off_t pg_start,int type)
  1311. {
  1312. int i;
  1314. CACHE_FLUSH ();
  1316. if (pg_start < intel_i830_private.gtt_entries) {
  1317. printk ("Trying to disable local/stolen memoryn");
  1318. return (-EINVAL);
  1319. }
  1321. for (i = pg_start; i < (mem->page_count + pg_start); i++)
  1322. OUTREG32(intel_i830_private.registers,I810_PTE_BASE + (i * 4),agp_bridge.scratch_page);
  1324. CACHE_FLUSH();
  1326. agp_bridge.tlb_flush(mem);
  1328. return (0);
  1329. }
  1331. static agp_memory *intel_i830_alloc_by_type(size_t pg_count,int type)
  1332. {
  1333. agp_memory *nw;
  1335. /* always return NULL for now */
  1336. if (type == AGP_DCACHE_MEMORY) return(NULL);
  1338. if (type == AGP_PHYS_MEMORY) {
  1339. unsigned long physical;
  1341. /* The i830 requires a physical address to program
  1342.  * it's mouse pointer into hardware. However the
  1343.  * Xserver still writes to it through the agp
  1344.  * aperture
  1345.  */
  1347. if (pg_count != 1) return(NULL);
  1349. nw = agp_create_memory(1);
  1351. if (nw == NULL) return(NULL);
  1353. MOD_INC_USE_COUNT;
  1354. nw->memory[0] = agp_bridge.agp_alloc_page();
  1355. physical = nw->memory[0];
  1356. if (nw->memory[0] == 0) {
  1357. /* free this structure */
  1358. agp_free_memory(nw);
  1359. return(NULL);
  1360. }
  1362. nw->memory[0] = agp_bridge.mask_memory(virt_to_phys((void *) nw->memory[0]),type);
  1363. nw->page_count = 1;
  1364. nw->num_scratch_pages = 1;
  1365. nw->type = AGP_PHYS_MEMORY;
  1366. nw->physical = virt_to_phys((void *) physical);
  1367. return(nw);
  1368. }
  1370. return(NULL);
  1371. }
  1373. static int __init intel_i830_setup(struct pci_dev *i830_dev)
  1374. {
  1375. intel_i830_private.i830_dev = i830_dev;
  1377. agp_bridge.masks = intel_i810_masks;
  1378. agp_bridge.num_of_masks = 3;
  1379. agp_bridge.aperture_sizes = (void *) intel_i830_sizes;
  1380. agp_bridge.size_type = FIXED_APER_SIZE;
  1381. agp_bridge.num_aperture_sizes = 2;
  1383. agp_bridge.dev_private_data = (void *) &intel_i830_private;
  1384. agp_bridge.needs_scratch_page = TRUE;
  1386. agp_bridge.configure = intel_i830_configure;
  1387. agp_bridge.fetch_size = intel_i830_fetch_size;
  1388. agp_bridge.cleanup = intel_i830_cleanup;
  1389. agp_bridge.tlb_flush = intel_i810_tlbflush;
  1390. agp_bridge.mask_memory = intel_i810_mask_memory;
  1391. agp_bridge.agp_enable = intel_i810_agp_enable;
  1392. agp_bridge.cache_flush = global_cache_flush;
  1394. agp_bridge.create_gatt_table = intel_i830_create_gatt_table;
  1395. agp_bridge.free_gatt_table = intel_i830_free_gatt_table;
  1397. agp_bridge.insert_memory = intel_i830_insert_entries;
  1398. agp_bridge.remove_memory = intel_i830_remove_entries;
  1399. agp_bridge.alloc_by_type = intel_i830_alloc_by_type;
  1400. agp_bridge.free_by_type = intel_i810_free_by_type;
  1401. agp_bridge.agp_alloc_page = agp_generic_alloc_page;
  1402. agp_bridge.agp_destroy_page = agp_generic_destroy_page;
  1404. agp_bridge.suspend = agp_generic_suspend;
  1405. agp_bridge.resume = agp_generic_resume;
  1406. agp_bridge.cant_use_aperture = 0;
  1408. return(0);
  1409. }
  1411. #endif /* CONFIG_AGP_I810 */
  1412.  
  1413.  #ifdef CONFIG_AGP_INTEL
  1415. #endif /* CONFIG_AGP_I810 */
  1417. #ifdef CONFIG_AGP_INTEL
  1419. static int intel_fetch_size(void)
  1420. {
  1421. int i;
  1422. u16 temp;
  1423. aper_size_info_16 *values;
  1425. pci_read_config_word(agp_bridge.dev, INTEL_APSIZE, &temp);
  1426. values = A_SIZE_16(agp_bridge.aperture_sizes);
  1428. for (i = 0; i < agp_bridge.num_aperture_sizes; i++) {
  1429. if (temp == values[i].size_value) {
  1430. agp_bridge.previous_size =
  1431.     agp_bridge.current_size = (void *) (values + i);
  1432. agp_bridge.aperture_size_idx = i;
  1433. return values[i].size;
  1434. }
  1435. }
  1437. return 0;
  1438. }
  1441. static int intel_8xx_fetch_size(void)
  1442. {
  1443. int i;
  1444. u8 temp;
  1445. aper_size_info_8 *values;
  1447. pci_read_config_byte(agp_bridge.dev, INTEL_APSIZE, &temp);
  1448. values = A_SIZE_8(agp_bridge.aperture_sizes);
  1450. for (i = 0; i < agp_bridge.num_aperture_sizes; i++) {
  1451. if (temp == values[i].size_value) {
  1452. agp_bridge.previous_size =
  1453.     agp_bridge.current_size = (void *) (values + i);
  1454. agp_bridge.aperture_size_idx = i;
  1455. return values[i].size;
  1456. }
  1457. }
  1459. return 0;
  1460. }
  1462. static void intel_tlbflush(agp_memory * mem)
  1463. {
  1464. pci_write_config_dword(agp_bridge.dev, INTEL_AGPCTRL, 0x2200);
  1465. pci_write_config_dword(agp_bridge.dev, INTEL_AGPCTRL, 0x2280);
  1466. }
  1469. static void intel_8xx_tlbflush(agp_memory * mem)
  1470. {
  1471.   u32 temp;
  1472.   pci_read_config_dword(agp_bridge.dev, INTEL_AGPCTRL, &temp);
  1473.   pci_write_config_dword(agp_bridge.dev, INTEL_AGPCTRL, temp & ~(1 << 7));
  1474.   pci_read_config_dword(agp_bridge.dev, INTEL_AGPCTRL, &temp);
  1475.   pci_write_config_dword(agp_bridge.dev, INTEL_AGPCTRL, temp | (1 << 7));
  1476. }
  1479. static void intel_cleanup(void)
  1480. {
  1481. u16 temp;
  1482. aper_size_info_16 *previous_size;
  1484. previous_size = A_SIZE_16(agp_bridge.previous_size);
  1485. pci_read_config_word(agp_bridge.dev, INTEL_NBXCFG, &temp);
  1486. pci_write_config_word(agp_bridge.dev, INTEL_NBXCFG, temp & ~(1 << 9));
  1487. pci_write_config_word(agp_bridge.dev, INTEL_APSIZE,
  1488.       previous_size->size_value);
  1489. }
  1492. static void intel_8xx_cleanup(void)
  1493. {
  1494. u16 temp;
  1495. aper_size_info_8 *previous_size;
  1497. previous_size = A_SIZE_8(agp_bridge.previous_size);
  1498. pci_read_config_word(agp_bridge.dev, INTEL_NBXCFG, &temp);
  1499. pci_write_config_word(agp_bridge.dev, INTEL_NBXCFG, temp & ~(1 << 9));
  1500. pci_write_config_byte(agp_bridge.dev, INTEL_APSIZE,
  1501.       previous_size->size_value);
  1502. }
  1505. static int intel_configure(void)
  1506. {
  1507. u32 temp;
  1508. u16 temp2;
  1509. aper_size_info_16 *current_size;
  1511. current_size = A_SIZE_16(agp_bridge.current_size);
  1513. /* aperture size */
  1514. pci_write_config_word(agp_bridge.dev, INTEL_APSIZE,
  1515.       current_size->size_value);
  1517. /* address to map to */
  1518. pci_read_config_dword(agp_bridge.dev, INTEL_APBASE, &temp);
  1519. agp_bridge.gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  1521. /* attbase - aperture base */
  1522. pci_write_config_dword(agp_bridge.dev, INTEL_ATTBASE,
  1523.        agp_bridge.gatt_bus_addr);
  1525. /* agpctrl */
  1526. pci_write_config_dword(agp_bridge.dev, INTEL_AGPCTRL, 0x2280);
  1528. /* paccfg/nbxcfg */
  1529. pci_read_config_word(agp_bridge.dev, INTEL_NBXCFG, &temp2);
  1530. pci_write_config_word(agp_bridge.dev, INTEL_NBXCFG,
  1531.       (temp2 & ~(1 << 10)) | (1 << 9));
  1532. /* clear any possible error conditions */
  1533. pci_write_config_byte(agp_bridge.dev, INTEL_ERRSTS + 1, 7);
  1534. return 0;
  1535. }
  1537. static void intel_820_tlbflush(agp_memory * mem)
  1538. {
  1539.   return;
  1540. }
  1542. static void intel_820_cleanup(void)
  1543. {
  1544. u8 temp;
  1545. aper_size_info_8 *previous_size;
  1547. previous_size = A_SIZE_8(agp_bridge.previous_size);
  1548. pci_read_config_byte(agp_bridge.dev, INTEL_I820_RDCR, &temp);
  1549. pci_write_config_byte(agp_bridge.dev, INTEL_I820_RDCR, 
  1550.       temp & ~(1 << 1));
  1551. pci_write_config_byte(agp_bridge.dev, INTEL_APSIZE,
  1552.       previous_size->size_value);
  1553. }
  1556. static int intel_820_configure(void)
  1557. {
  1558. u32 temp;
  1559.   u8 temp2; 
  1560. aper_size_info_8 *current_size;
  1562. current_size = A_SIZE_8(agp_bridge.current_size);
  1564. /* aperture size */
  1565. pci_write_config_byte(agp_bridge.dev, INTEL_APSIZE,
  1566.       current_size->size_value); 
  1568. /* address to map to */
  1569. pci_read_config_dword(agp_bridge.dev, INTEL_APBASE, &temp);
  1570. agp_bridge.gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  1572. /* attbase - aperture base */
  1573. pci_write_config_dword(agp_bridge.dev, INTEL_ATTBASE,
  1574.        agp_bridge.gatt_bus_addr); 
  1576. /* agpctrl */
  1577. pci_write_config_dword(agp_bridge.dev, INTEL_AGPCTRL, 0x0000); 
  1579. /* global enable aperture access */
  1580. /* This flag is not accessed through MCHCFG register as in */
  1581. /* i850 chipset. */
  1582. pci_read_config_byte(agp_bridge.dev, INTEL_I820_RDCR, &temp2);
  1583. pci_write_config_byte(agp_bridge.dev, INTEL_I820_RDCR, 
  1584.       temp2 | (1 << 1));
  1585. /* clear any possible AGP-related error conditions */
  1586. pci_write_config_word(agp_bridge.dev, INTEL_I820_ERRSTS, 0x001c); 
  1587. return 0;
  1588. }
  1590. static int intel_830mp_configure(void)
  1591. {
  1592.        u32 temp;
  1593.        u16 temp2;
  1594.        aper_size_info_8 *current_size;
  1596.        current_size = A_SIZE_8(agp_bridge.current_size);
  1598.        /* aperture size */
  1599.        pci_write_config_byte(agp_bridge.dev, INTEL_APSIZE,
  1600.                              current_size->size_value);
  1602.        /* address to map to */
  1603.        pci_read_config_dword(agp_bridge.dev, INTEL_APBASE, &temp);
  1604.        agp_bridge.gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  1606.        /* attbase - aperture base */
  1607.        pci_write_config_dword(agp_bridge.dev, INTEL_ATTBASE,
  1608.                               agp_bridge.gatt_bus_addr);
  1610.        /* agpctrl */
  1611.        pci_write_config_dword(agp_bridge.dev, INTEL_AGPCTRL, 0x0000);
  1613.        /* gmch */
  1614.        pci_read_config_word(agp_bridge.dev, INTEL_NBXCFG, &temp2);
  1615.        pci_write_config_word(agp_bridge.dev, INTEL_NBXCFG,
  1616.                              temp2 | (1 << 9));
  1617.        /* clear any possible AGP-related error conditions */
  1618.        pci_write_config_word(agp_bridge.dev, INTEL_I830_ERRSTS, 0x1c);
  1619.        return 0;
  1620. }
  1621.        
  1624. static int intel_840_configure(void)
  1625. {
  1626. u32 temp;
  1627. u16 temp2;
  1628. aper_size_info_8 *current_size;
  1630. current_size = A_SIZE_8(agp_bridge.current_size);
  1632. /* aperture size */
  1633. pci_write_config_byte(agp_bridge.dev, INTEL_APSIZE,
  1634.       current_size->size_value); 
  1636. /* address to map to */
  1637. pci_read_config_dword(agp_bridge.dev, INTEL_APBASE, &temp);
  1638. agp_bridge.gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  1640. /* attbase - aperture base */
  1641. pci_write_config_dword(agp_bridge.dev, INTEL_ATTBASE,
  1642.        agp_bridge.gatt_bus_addr); 
  1644. /* agpctrl */
  1645. pci_write_config_dword(agp_bridge.dev, INTEL_AGPCTRL, 0x0000); 
  1647. /* mcgcfg */
  1648. pci_read_config_word(agp_bridge.dev, INTEL_I840_MCHCFG, &temp2);
  1649. pci_write_config_word(agp_bridge.dev, INTEL_I840_MCHCFG,
  1650.       temp2 | (1 << 9));
  1651. /* clear any possible error conditions */
  1652. pci_write_config_word(agp_bridge.dev, INTEL_I840_ERRSTS, 0xc000); 
  1653. return 0;
  1654. }
  1656. static int intel_845_configure(void)
  1657. {
  1658. u32 temp;
  1659. u8 temp2;
  1660. aper_size_info_8 *current_size;
  1662. current_size = A_SIZE_8(agp_bridge.current_size);
  1664. /* aperture size */
  1665. pci_write_config_byte(agp_bridge.dev, INTEL_APSIZE,
  1666.       current_size->size_value); 
  1668. /* address to map to */
  1669. pci_read_config_dword(agp_bridge.dev, INTEL_APBASE, &temp);
  1670. agp_bridge.gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  1672. /* attbase - aperture base */
  1673. pci_write_config_dword(agp_bridge.dev, INTEL_ATTBASE,
  1674.        agp_bridge.gatt_bus_addr); 
  1676. /* agpctrl */
  1677. pci_write_config_dword(agp_bridge.dev, INTEL_AGPCTRL, 0x0000); 
  1679. /* agpm */
  1680. pci_read_config_byte(agp_bridge.dev, INTEL_I845_AGPM, &temp2);
  1681. pci_write_config_byte(agp_bridge.dev, INTEL_I845_AGPM,
  1682.       temp2 | (1 << 1));
  1683. /* clear any possible error conditions */
  1684. pci_write_config_word(agp_bridge.dev, INTEL_I845_ERRSTS, 0x001c); 
  1685. return 0;
  1686. }
  1688. static int intel_850_configure(void)
  1689. {
  1690. u32 temp;
  1691. u16 temp2;
  1692. aper_size_info_8 *current_size;
  1694. current_size = A_SIZE_8(agp_bridge.current_size);
  1696. /* aperture size */
  1697. pci_write_config_byte(agp_bridge.dev, INTEL_APSIZE,
  1698.       current_size->size_value); 
  1700. /* address to map to */
  1701. pci_read_config_dword(agp_bridge.dev, INTEL_APBASE, &temp);
  1702. agp_bridge.gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  1704. /* attbase - aperture base */
  1705. pci_write_config_dword(agp_bridge.dev, INTEL_ATTBASE,
  1706.        agp_bridge.gatt_bus_addr); 
  1708. /* agpctrl */
  1709. pci_write_config_dword(agp_bridge.dev, INTEL_AGPCTRL, 0x0000); 
  1711. /* mcgcfg */
  1712. pci_read_config_word(agp_bridge.dev, INTEL_I850_MCHCFG, &temp2);
  1713. pci_write_config_word(agp_bridge.dev, INTEL_I850_MCHCFG,
  1714.       temp2 | (1 << 9));
  1715. /* clear any possible AGP-related error conditions */
  1716. pci_write_config_word(agp_bridge.dev, INTEL_I850_ERRSTS, 0x001c); 
  1717. return 0;
  1718. }
  1720. static int intel_860_configure(void)
  1721. {
  1722. u32 temp;
  1723. u16 temp2;
  1724. aper_size_info_8 *current_size;
  1726. current_size = A_SIZE_8(agp_bridge.current_size);
  1728. /* aperture size */
  1729. pci_write_config_byte(agp_bridge.dev, INTEL_APSIZE,
  1730.       current_size->size_value);
  1732. /* address to map to */
  1733. pci_read_config_dword(agp_bridge.dev, INTEL_APBASE, &temp);
  1734. agp_bridge.gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  1736. /* attbase - aperture base */
  1737. pci_write_config_dword(agp_bridge.dev, INTEL_ATTBASE,
  1738.        agp_bridge.gatt_bus_addr);
  1740. /* agpctrl */
  1741. pci_write_config_dword(agp_bridge.dev, INTEL_AGPCTRL, 0x0000);
  1743. /* mcgcfg */
  1744. pci_read_config_word(agp_bridge.dev, INTEL_I860_MCHCFG, &temp2);
  1745. pci_write_config_word(agp_bridge.dev, INTEL_I860_MCHCFG,
  1746.       temp2 | (1 << 9));
  1747. /* clear any possible AGP-related error conditions */
  1748. pci_write_config_word(agp_bridge.dev, INTEL_I860_ERRSTS, 0xf700);
  1749. return 0;
  1750. }
  1753. static unsigned long intel_mask_memory(unsigned long addr, int type)
  1754. {
  1755. /* Memory type is ignored */
  1757. return addr | agp_bridge.masks[0].mask;
  1758. }
  1760. static void intel_resume(void)
  1761. {
  1762. intel_configure();
  1763. }
  1765. /* Setup function */
  1766. static gatt_mask intel_generic_masks[] =
  1767. {
  1768. {0x00000017, 0}
  1769. };
  1771. static aper_size_info_8 intel_8xx_sizes[7] =
  1772. {
  1773. {256, 65536, 6, 0},
  1774. {128, 32768, 5, 32},
  1775. {64, 16384, 4, 48},
  1776. {32, 8192, 3, 56},
  1777. {16, 4096, 2, 60},
  1778. {8, 2048, 1, 62},
  1779. {4, 1024, 0, 63}
  1780. };
  1782. static aper_size_info_16 intel_generic_sizes[7] =
  1783. {
  1784. {256, 65536, 6, 0},
  1785. {128, 32768, 5, 32},
  1786. {64, 16384, 4, 48},
  1787. {32, 8192, 3, 56},
  1788. {16, 4096, 2, 60},
  1789. {8, 2048, 1, 62},
  1790. {4, 1024, 0, 63}
  1791. };
  1793. static aper_size_info_8 intel_830mp_sizes[4] = 
  1794. {
  1795.   {256, 65536, 6, 0},
  1796.   {128, 32768, 5, 32},
  1797.   {64, 16384, 4, 48},
  1798.   {32, 8192, 3, 56}
  1799. };
  1801. static int __init intel_generic_setup (struct pci_dev *pdev)
  1802. {
  1803. agp_bridge.masks = intel_generic_masks;
  1804. agp_bridge.num_of_masks = 1;
  1805. agp_bridge.aperture_sizes = (void *) intel_generic_sizes;
  1806. agp_bridge.size_type = U16_APER_SIZE;
  1807. agp_bridge.num_aperture_sizes = 7;
  1808. agp_bridge.dev_private_data = NULL;
  1809. agp_bridge.needs_scratch_page = FALSE;
  1810. agp_bridge.configure = intel_configure;
  1811. agp_bridge.fetch_size = intel_fetch_size;
  1812. agp_bridge.cleanup = intel_cleanup;
  1813. agp_bridge.tlb_flush = intel_tlbflush;
  1814. agp_bridge.mask_memory = intel_mask_memory;
  1815. agp_bridge.agp_enable = agp_generic_agp_enable;
  1816. agp_bridge.cache_flush = global_cache_flush;
  1817. agp_bridge.create_gatt_table = agp_generic_create_gatt_table;
  1818. agp_bridge.free_gatt_table = agp_generic_free_gatt_table;
  1819. agp_bridge.insert_memory = agp_generic_insert_memory;
  1820. agp_bridge.remove_memory = agp_generic_remove_memory;
  1821. agp_bridge.alloc_by_type = agp_generic_alloc_by_type;
  1822. agp_bridge.free_by_type = agp_generic_free_by_type;
  1823. agp_bridge.agp_alloc_page = agp_generic_alloc_page;
  1824. agp_bridge.agp_destroy_page = agp_generic_destroy_page;
  1825. agp_bridge.suspend = agp_generic_suspend;
  1826. agp_bridge.resume = intel_resume;
  1827. agp_bridge.cant_use_aperture = 0;
  1829. return 0;
  1831. (void) pdev; /* unused */
  1832. }
  1836. static int __init intel_820_setup (struct pci_dev *pdev)
  1837. {
  1838.        agp_bridge.masks = intel_generic_masks;
  1839.        agp_bridge.num_of_masks = 1;
  1840.        agp_bridge.aperture_sizes = (void *) intel_8xx_sizes;
  1841.        agp_bridge.size_type = U8_APER_SIZE;
  1842.        agp_bridge.num_aperture_sizes = 7;
  1843.        agp_bridge.dev_private_data = NULL;
  1844.        agp_bridge.needs_scratch_page = FALSE;
  1845.        agp_bridge.configure = intel_820_configure;
  1846.        agp_bridge.fetch_size = intel_8xx_fetch_size;
  1847.        agp_bridge.cleanup = intel_820_cleanup;
  1848.        agp_bridge.tlb_flush = intel_820_tlbflush;
  1849.        agp_bridge.mask_memory = intel_mask_memory;
  1850.        agp_bridge.agp_enable = agp_generic_agp_enable;
  1851.        agp_bridge.cache_flush = global_cache_flush;
  1852.        agp_bridge.create_gatt_table = agp_generic_create_gatt_table;
  1853.        agp_bridge.free_gatt_table = agp_generic_free_gatt_table;
  1854.        agp_bridge.insert_memory = agp_generic_insert_memory;
  1855.        agp_bridge.remove_memory = agp_generic_remove_memory;
  1856.        agp_bridge.alloc_by_type = agp_generic_alloc_by_type;
  1857.        agp_bridge.free_by_type = agp_generic_free_by_type;
  1858.        agp_bridge.agp_alloc_page = agp_generic_alloc_page;
  1859.        agp_bridge.agp_destroy_page = agp_generic_destroy_page;
  1860.        agp_bridge.suspend = agp_generic_suspend;
  1861.        agp_bridge.resume = agp_generic_resume;
  1862.        agp_bridge.cant_use_aperture = 0;
  1864.        return 0;
  1866.        (void) pdev; /* unused */
  1867. }
  1869. static int __init intel_830mp_setup (struct pci_dev *pdev)
  1870. {
  1871.        agp_bridge.masks = intel_generic_masks;
  1872.        agp_bridge.num_of_masks = 1;
  1873.        agp_bridge.aperture_sizes = (void *) intel_830mp_sizes;
  1874.        agp_bridge.size_type = U8_APER_SIZE;
  1875.        agp_bridge.num_aperture_sizes = 4;
  1876.        agp_bridge.dev_private_data = NULL;
  1877.        agp_bridge.needs_scratch_page = FALSE;
  1878.        agp_bridge.configure = intel_830mp_configure;
  1879.        agp_bridge.fetch_size = intel_8xx_fetch_size;
  1880.        agp_bridge.cleanup = intel_8xx_cleanup;
  1881.        agp_bridge.tlb_flush = intel_8xx_tlbflush;
  1882.        agp_bridge.mask_memory = intel_mask_memory;
  1883.        agp_bridge.agp_enable = agp_generic_agp_enable;
  1884.        agp_bridge.cache_flush = global_cache_flush;
  1885.        agp_bridge.create_gatt_table = agp_generic_create_gatt_table;
  1886.        agp_bridge.free_gatt_table = agp_generic_free_gatt_table;
  1887.        agp_bridge.insert_memory = agp_generic_insert_memory;
  1888.        agp_bridge.remove_memory = agp_generic_remove_memory;
  1889.        agp_bridge.alloc_by_type = agp_generic_alloc_by_type;
  1890.        agp_bridge.free_by_type = agp_generic_free_by_type;
  1891.        agp_bridge.agp_alloc_page = agp_generic_alloc_page;
  1892.        agp_bridge.agp_destroy_page = agp_generic_destroy_page;
  1893.        agp_bridge.suspend = agp_generic_suspend;
  1894.        agp_bridge.resume = agp_generic_resume;
  1895.        agp_bridge.cant_use_aperture = 0;
  1896.        return 0;
  1898.        (void) pdev; /* unused */
  1899. }
  1901. static int __init intel_840_setup (struct pci_dev *pdev)
  1902. {
  1903. agp_bridge.masks = intel_generic_masks;
  1904. agp_bridge.num_of_masks = 1;
  1905. agp_bridge.aperture_sizes = (void *) intel_8xx_sizes;
  1906. agp_bridge.size_type = U8_APER_SIZE;
  1907. agp_bridge.num_aperture_sizes = 7;
  1908. agp_bridge.dev_private_data = NULL;
  1909. agp_bridge.needs_scratch_page = FALSE;
  1910. agp_bridge.configure = intel_840_configure;
  1911. agp_bridge.fetch_size = intel_8xx_fetch_size;
  1912. agp_bridge.cleanup = intel_8xx_cleanup;
  1913. agp_bridge.tlb_flush = intel_8xx_tlbflush;
  1914. agp_bridge.mask_memory = intel_mask_memory;
  1915. agp_bridge.agp_enable = agp_generic_agp_enable;
  1916. agp_bridge.cache_flush = global_cache_flush;
  1917. agp_bridge.create_gatt_table = agp_generic_create_gatt_table;
  1918. agp_bridge.free_gatt_table = agp_generic_free_gatt_table;
  1919. agp_bridge.insert_memory = agp_generic_insert_memory;
  1920. agp_bridge.remove_memory = agp_generic_remove_memory;
  1921. agp_bridge.alloc_by_type = agp_generic_alloc_by_type;
  1922. agp_bridge.free_by_type = agp_generic_free_by_type;
  1923. agp_bridge.agp_alloc_page = agp_generic_alloc_page;
  1924. agp_bridge.agp_destroy_page = agp_generic_destroy_page;
  1925. agp_bridge.suspend = agp_generic_suspend;
  1926. agp_bridge.resume = agp_generic_resume;
  1927. agp_bridge.cant_use_aperture = 0;
  1929. return 0;
  1931. (void) pdev; /* unused */
  1932. }
  1934. static int __init intel_845_setup (struct pci_dev *pdev)
  1935. {
  1936. agp_bridge.masks = intel_generic_masks;
  1937. agp_bridge.num_of_masks = 1;
  1938. agp_bridge.aperture_sizes = (void *) intel_8xx_sizes;
  1939. agp_bridge.size_type = U8_APER_SIZE;
  1940. agp_bridge.num_aperture_sizes = 7;
  1941. agp_bridge.dev_private_data = NULL;
  1942. agp_bridge.needs_scratch_page = FALSE;
  1943. agp_bridge.configure = intel_845_configure;
  1944. agp_bridge.fetch_size = intel_8xx_fetch_size;
  1945. agp_bridge.cleanup = intel_8xx_cleanup;
  1946. agp_bridge.tlb_flush = intel_8xx_tlbflush;
  1947. agp_bridge.mask_memory = intel_mask_memory;
  1948. agp_bridge.agp_enable = agp_generic_agp_enable;
  1949. agp_bridge.cache_flush = global_cache_flush;
  1950. agp_bridge.create_gatt_table = agp_generic_create_gatt_table;
  1951. agp_bridge.free_gatt_table = agp_generic_free_gatt_table;
  1952. agp_bridge.insert_memory = agp_generic_insert_memory;
  1953. agp_bridge.remove_memory = agp_generic_remove_memory;
  1954. agp_bridge.alloc_by_type = agp_generic_alloc_by_type;
  1955. agp_bridge.free_by_type = agp_generic_free_by_type;
  1956. agp_bridge.agp_alloc_page = agp_generic_alloc_page;
  1957. agp_bridge.agp_destroy_page = agp_generic_destroy_page;
  1958. agp_bridge.suspend = agp_generic_suspend;
  1959. agp_bridge.resume = agp_generic_resume;
  1960. agp_bridge.cant_use_aperture = 0;
  1962. return 0;
  1964. (void) pdev; /* unused */
  1965. }
  1967. static int __init intel_850_setup (struct pci_dev *pdev)
  1968. {
  1969. agp_bridge.masks = intel_generic_masks;
  1970. agp_bridge.num_of_masks = 1;
  1971. agp_bridge.aperture_sizes = (void *) intel_8xx_sizes;
  1972. agp_bridge.size_type = U8_APER_SIZE;
  1973. agp_bridge.num_aperture_sizes = 7;
  1974. agp_bridge.dev_private_data = NULL;
  1975. agp_bridge.needs_scratch_page = FALSE;
  1976. agp_bridge.configure = intel_850_configure;
  1977. agp_bridge.fetch_size = intel_8xx_fetch_size;
  1978. agp_bridge.cleanup = intel_8xx_cleanup;
  1979. agp_bridge.tlb_flush = intel_8xx_tlbflush;
  1980. agp_bridge.mask_memory = intel_mask_memory;
  1981. agp_bridge.agp_enable = agp_generic_agp_enable;
  1982. agp_bridge.cache_flush = global_cache_flush;
  1983. agp_bridge.create_gatt_table = agp_generic_create_gatt_table;
  1984. agp_bridge.free_gatt_table = agp_generic_free_gatt_table;
  1985. agp_bridge.insert_memory = agp_generic_insert_memory;
  1986. agp_bridge.remove_memory = agp_generic_remove_memory;
  1987. agp_bridge.alloc_by_type = agp_generic_alloc_by_type;
  1988. agp_bridge.free_by_type = agp_generic_free_by_type;
  1989. agp_bridge.agp_alloc_page = agp_generic_alloc_page;
  1990. agp_bridge.agp_destroy_page = agp_generic_destroy_page;
  1991. agp_bridge.suspend = agp_generic_suspend;
  1992. agp_bridge.resume = agp_generic_resume;
  1993. agp_bridge.cant_use_aperture = 0;
  1995. return 0;
  1997. (void) pdev; /* unused */
  1998. }
  2000. static int __init intel_860_setup (struct pci_dev *pdev)
  2001. {
  2002. agp_bridge.masks = intel_generic_masks;
  2003. agp_bridge.num_of_masks = 1;
  2004. agp_bridge.aperture_sizes = (void *) intel_8xx_sizes;
  2005. agp_bridge.size_type = U8_APER_SIZE;
  2006. agp_bridge.num_aperture_sizes = 7;
  2007. agp_bridge.dev_private_data = NULL;
  2008. agp_bridge.needs_scratch_page = FALSE;
  2009. agp_bridge.configure = intel_860_configure;
  2010. agp_bridge.fetch_size = intel_8xx_fetch_size;
  2011. agp_bridge.cleanup = intel_8xx_cleanup;
  2012. agp_bridge.tlb_flush = intel_8xx_tlbflush;
  2013. agp_bridge.mask_memory = intel_mask_memory;
  2014. agp_bridge.agp_enable = agp_generic_agp_enable;
  2015. agp_bridge.cache_flush = global_cache_flush;
  2016. agp_bridge.create_gatt_table = agp_generic_create_gatt_table;
  2017. agp_bridge.free_gatt_table = agp_generic_free_gatt_table;
  2018. agp_bridge.insert_memory = agp_generic_insert_memory;
  2019. agp_bridge.remove_memory = agp_generic_remove_memory;
  2020. agp_bridge.alloc_by_type = agp_generic_alloc_by_type;
  2021. agp_bridge.free_by_type = agp_generic_free_by_type;
  2022. agp_bridge.agp_alloc_page = agp_generic_alloc_page;
  2023. agp_bridge.agp_destroy_page = agp_generic_destroy_page;
  2024. agp_bridge.suspend = agp_generic_suspend;
  2025. agp_bridge.resume = agp_generic_resume;
  2026. agp_bridge.cant_use_aperture = 0;
  2028. return 0;
  2030. (void) pdev; /* unused */
  2031. }
  2033. #endif /* CONFIG_AGP_INTEL */
  2035. #ifdef CONFIG_AGP_VIA
  2037. static int via_fetch_size(void)
  2038. {
  2039. int i;
  2040. u8 temp;
  2041. aper_size_info_8 *values;
  2043. values = A_SIZE_8(agp_bridge.aperture_sizes);
  2044. pci_read_config_byte(agp_bridge.dev, VIA_APSIZE, &temp);
  2045. for (i = 0; i < agp_bridge.num_aperture_sizes; i++) {
  2046. if (temp == values[i].size_value) {
  2047. agp_bridge.previous_size =
  2048.     agp_bridge.current_size = (void *) (values + i);
  2049. agp_bridge.aperture_size_idx = i;
  2050. return values[i].size;
  2051. }
  2052. }
  2054. return 0;
  2055. }
  2057. static int via_configure(void)
  2058. {
  2059. u32 temp;
  2060. aper_size_info_8 *current_size;
  2062. current_size = A_SIZE_8(agp_bridge.current_size);
  2063. /* aperture size */
  2064. pci_write_config_byte(agp_bridge.dev, VIA_APSIZE,
  2065.       current_size->size_value);
  2066. /* address to map too */
  2067. pci_read_config_dword(agp_bridge.dev, VIA_APBASE, &temp);
  2068. agp_bridge.gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  2070. /* GART control register */
  2071. pci_write_config_dword(agp_bridge.dev, VIA_GARTCTRL, 0x0000000f);
  2073. /* attbase - aperture GATT base */
  2074. pci_write_config_dword(agp_bridge.dev, VIA_ATTBASE,
  2075.     (agp_bridge.gatt_bus_addr & 0xfffff000) | 3);
  2076. return 0;
  2077. }
  2079. static void via_cleanup(void)
  2080. {
  2081. aper_size_info_8 *previous_size;
  2083. previous_size = A_SIZE_8(agp_bridge.previous_size);
  2084. pci_write_config_byte(agp_bridge.dev, VIA_APSIZE,
  2085.       previous_size->size_value);
  2086. /* Do not disable by writing 0 to VIA_ATTBASE, it screws things up
  2087.  * during reinitialization.
  2088.  */
  2089. }
  2091. static void via_tlbflush(agp_memory * mem)
  2092. {
  2093. pci_write_config_dword(agp_bridge.dev, VIA_GARTCTRL, 0x0000008f);
  2094. pci_write_config_dword(agp_bridge.dev, VIA_GARTCTRL, 0x0000000f);
  2095. }
  2097. static unsigned long via_mask_memory(unsigned long addr, int type)
  2098. {
  2099. /* Memory type is ignored */
  2101. return addr | agp_bridge.masks[0].mask;
  2102. }
  2104. static aper_size_info_8 via_generic_sizes[7] =
  2105. {
  2106. {256, 65536, 6, 0},
  2107. {128, 32768, 5, 128},
  2108. {64, 16384, 4, 192},
  2109. {32, 8192, 3, 224},
  2110. {16, 4096, 2, 240},
  2111. {8, 2048, 1, 248},
  2112. {4, 1024, 0, 252}
  2113. };
  2115. static gatt_mask via_generic_masks[] =
  2116. {
  2117. {0x00000000, 0}
  2118. };
  2120. static int __init via_generic_setup (struct pci_dev *pdev)
  2121. {
  2122. agp_bridge.masks = via_generic_masks;
  2123. agp_bridge.num_of_masks = 1;
  2124. agp_bridge.aperture_sizes = (void *) via_generic_sizes;
  2125. agp_bridge.size_type = U8_APER_SIZE;
  2126. agp_bridge.num_aperture_sizes = 7;
  2127. agp_bridge.dev_private_data = NULL;
  2128. agp_bridge.needs_scratch_page = FALSE;
  2129. agp_bridge.configure = via_configure;
  2130. agp_bridge.fetch_size = via_fetch_size;
  2131. agp_bridge.cleanup = via_cleanup;
  2132. agp_bridge.tlb_flush = via_tlbflush;
  2133. agp_bridge.mask_memory = via_mask_memory;
  2134. agp_bridge.agp_enable = agp_generic_agp_enable;
  2135. agp_bridge.cache_flush = global_cache_flush;
  2136. agp_bridge.create_gatt_table = agp_generic_create_gatt_table;
  2137. agp_bridge.free_gatt_table = agp_generic_free_gatt_table;
  2138. agp_bridge.insert_memory = agp_generic_insert_memory;
  2139. agp_bridge.remove_memory = agp_generic_remove_memory;
  2140. agp_bridge.alloc_by_type = agp_generic_alloc_by_type;
  2141. agp_bridge.free_by_type = agp_generic_free_by_type;
  2142. agp_bridge.agp_alloc_page = agp_generic_alloc_page;
  2143. agp_bridge.agp_destroy_page = agp_generic_destroy_page;
  2144. agp_bridge.suspend = agp_generic_suspend;
  2145. agp_bridge.resume = agp_generic_resume;
  2146. agp_bridge.cant_use_aperture = 0;
  2148. return 0;
  2150. (void) pdev; /* unused */
  2151. }
  2153. #endif /* CONFIG_AGP_VIA */
  2155. #ifdef CONFIG_AGP_SIS
  2157. static int sis_fetch_size(void)
  2158. {
  2159. u8 temp_size;
  2160. int i;
  2161. aper_size_info_8 *values;
  2163. pci_read_config_byte(agp_bridge.dev, SIS_APSIZE, &temp_size);
  2164. values = A_SIZE_8(agp_bridge.aperture_sizes);
  2165. for (i = 0; i < agp_bridge.num_aperture_sizes; i++) {
  2166. if ((temp_size == values[i].size_value) ||
  2167.     ((temp_size & ~(0x03)) ==
  2168.      (values[i].size_value & ~(0x03)))) {
  2169. agp_bridge.previous_size =
  2170.     agp_bridge.current_size = (void *) (values + i);
  2172. agp_bridge.aperture_size_idx = i;
  2173. return values[i].size;
  2174. }
  2175. }
  2177. return 0;
  2178. }
  2181. static void sis_tlbflush(agp_memory * mem)
  2182. {
  2183. pci_write_config_byte(agp_bridge.dev, SIS_TLBFLUSH, 0x02);
  2184. }
  2186. static int sis_configure(void)
  2187. {
  2188. u32 temp;
  2189. aper_size_info_8 *current_size;
  2191. current_size = A_SIZE_8(agp_bridge.current_size);
  2192. pci_write_config_byte(agp_bridge.dev, SIS_TLBCNTRL, 0x05);
  2193. pci_read_config_dword(agp_bridge.dev, SIS_APBASE, &temp);
  2194. agp_bridge.gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  2195. pci_write_config_dword(agp_bridge.dev, SIS_ATTBASE,
  2196.        agp_bridge.gatt_bus_addr);
  2197. pci_write_config_byte(agp_bridge.dev, SIS_APSIZE,
  2198.       current_size->size_value);
  2199. return 0;
  2200. }
  2202. static void sis_cleanup(void)
  2203. {
  2204. aper_size_info_8 *previous_size;
  2206. previous_size = A_SIZE_8(agp_bridge.previous_size);
  2207. pci_write_config_byte(agp_bridge.dev, SIS_APSIZE,
  2208.       (previous_size->size_value & ~(0x03)));
  2209. }
  2211. static unsigned long sis_mask_memory(unsigned long addr, int type)
  2212. {
  2213. /* Memory type is ignored */
  2215. return addr | agp_bridge.masks[0].mask;
  2216. }
  2218. static aper_size_info_8 sis_generic_sizes[7] =
  2219. {
  2220. {256, 65536, 6, 99},
  2221. {128, 32768, 5, 83},
  2222. {64, 16384, 4, 67},
  2223. {32, 8192, 3, 51},
  2224. {16, 4096, 2, 35},
  2225. {8, 2048, 1, 19},
  2226. {4, 1024, 0, 3}
  2227. };
  2229. static gatt_mask sis_generic_masks[] =
  2230. {
  2231. {0x00000000, 0}
  2232. };
  2234. static int __init sis_generic_setup (struct pci_dev *pdev)
  2235. {
  2236. agp_bridge.masks = sis_generic_masks;
  2237. agp_bridge.num_of_masks = 1;
  2238. agp_bridge.aperture_sizes = (void *) sis_generic_sizes;
  2239. agp_bridge.size_type = U8_APER_SIZE;
  2240. agp_bridge.num_aperture_sizes = 7;
  2241. agp_bridge.dev_private_data = NULL;
  2242. agp_bridge.needs_scratch_page = FALSE;
  2243. agp_bridge.configure = sis_configure;
  2244. agp_bridge.fetch_size = sis_fetch_size;
  2245. agp_bridge.cleanup = sis_cleanup;
  2246. agp_bridge.tlb_flush = sis_tlbflush;
  2247. agp_bridge.mask_memory = sis_mask_memory;
  2248. agp_bridge.agp_enable = agp_generic_agp_enable;
  2249. agp_bridge.cache_flush = global_cache_flush;
  2250. agp_bridge.create_gatt_table = agp_generic_create_gatt_table;
  2251. agp_bridge.free_gatt_table = agp_generic_free_gatt_table;
  2252. agp_bridge.insert_memory = agp_generic_insert_memory;
  2253. agp_bridge.remove_memory = agp_generic_remove_memory;
  2254. agp_bridge.alloc_by_type = agp_generic_alloc_by_type;
  2255. agp_bridge.free_by_type = agp_generic_free_by_type;
  2256. agp_bridge.agp_alloc_page = agp_generic_alloc_page;
  2257. agp_bridge.agp_destroy_page = agp_generic_destroy_page;
  2258. agp_bridge.suspend = agp_generic_suspend;
  2259. agp_bridge.resume = agp_generic_resume;
  2260. agp_bridge.cant_use_aperture = 0;
  2262. return 0;
  2263. }
  2265. #endif /* CONFIG_AGP_SIS */
  2267. #ifdef CONFIG_AGP_AMD
  2269. typedef struct _amd_page_map {
  2270. unsigned long *real;
  2271. unsigned long *remapped;
  2272. } amd_page_map;
  2274. static struct _amd_irongate_private {
  2275. volatile u8 *registers;
  2276. amd_page_map **gatt_pages;
  2277. int num_tables;
  2278. } amd_irongate_private;
  2280. static int amd_create_page_map(amd_page_map *page_map)
  2281. {
  2282. int i;
  2284. page_map->real = (unsigned long *) __get_free_page(GFP_KERNEL);
  2285. if (page_map->real == NULL) {
  2286. return -ENOMEM;
  2287. }
  2288. set_bit(PG_reserved, &virt_to_page(page_map->real)->flags);
  2289. CACHE_FLUSH();
  2290. page_map->remapped = ioremap_nocache(virt_to_phys(page_map->real), 
  2291.     PAGE_SIZE);
  2292. if (page_map->remapped == NULL) {
  2293. clear_bit(PG_reserved, 
  2294.   &virt_to_page(page_map->real)->flags);
  2295. free_page((unsigned long) page_map->real);
  2296. page_map->real = NULL;
  2297. return -ENOMEM;
  2298. }
  2299. CACHE_FLUSH();
  2301. for(i = 0; i < PAGE_SIZE / sizeof(unsigned long); i++) {
  2302. page_map->remapped[i] = agp_bridge.scratch_page;
  2303. }
  2305. return 0;
  2306. }
  2308. static void amd_free_page_map(amd_page_map *page_map)
  2309. {
  2310. iounmap(page_map->remapped);
  2311. clear_bit(PG_reserved, 
  2312.   &virt_to_page(page_map->real)->flags);
  2313. free_page((unsigned long) page_map->real);
  2314. }
  2316. static void amd_free_gatt_pages(void)
  2317. {
  2318. int i;
  2319. amd_page_map **tables;
  2320. amd_page_map *entry;
  2322. tables = amd_irongate_private.gatt_pages;
  2323. for(i = 0; i < amd_irongate_private.num_tables; i++) {
  2324. entry = tables[i];
  2325. if (entry != NULL) {
  2326. if (entry->real != NULL) {
  2327. amd_free_page_map(entry);
  2328. }
  2329. kfree(entry);
  2330. }
  2331. }
  2332. kfree(tables);
  2333. }
  2335. static int amd_create_gatt_pages(int nr_tables)
  2336. {
  2337. amd_page_map **tables;
  2338. amd_page_map *entry;
  2339. int retval = 0;
  2340. int i;
  2342. tables = kmalloc((nr_tables + 1) * sizeof(amd_page_map *), 
  2343.  GFP_KERNEL);
  2344. if (tables == NULL) {
  2345. return -ENOMEM;
  2346. }
  2347. memset(tables, 0, sizeof(amd_page_map *) * (nr_tables + 1));
  2348. for (i = 0; i < nr_tables; i++) {
  2349. entry = kmalloc(sizeof(amd_page_map), GFP_KERNEL);
  2350. if (entry == NULL) {
  2351. retval = -ENOMEM;
  2352. break;
  2353. }
  2354. memset(entry, 0, sizeof(amd_page_map));
  2355. tables[i] = entry;
  2356. retval = amd_create_page_map(entry);
  2357. if (retval != 0) break;
  2358. }
  2359. amd_irongate_private.num_tables = nr_tables;
  2360. amd_irongate_private.gatt_pages = tables;
  2362. if (retval != 0) amd_free_gatt_pages();
  2364. return retval;
  2365. }
  2367. /* Since we don't need contigious memory we just try
  2368.  * to get the gatt table once
  2369.  */
  2371. #define GET_PAGE_DIR_OFF(addr) (addr >> 22)
  2372. #define GET_PAGE_DIR_IDX(addr) (GET_PAGE_DIR_OFF(addr) - 
  2373. GET_PAGE_DIR_OFF(agp_bridge.gart_bus_addr))
  2374. #define GET_GATT_OFF(addr) ((addr & 0x003ff000) >> 12) 
  2375. #define GET_GATT(addr) (amd_irongate_private.gatt_pages[
  2376. GET_PAGE_DIR_IDX(addr)]->remapped)
  2378. static int amd_create_gatt_table(void)
  2379. {
  2380. aper_size_info_lvl2 *value;
  2381. amd_page_map page_dir;
  2382. unsigned long addr;
  2383. int retval;
  2384. u32 temp;
  2385. int i;
  2387. value = A_SIZE_LVL2(agp_bridge.current_size);
  2388. retval = amd_create_page_map(&page_dir);
  2389. if (retval != 0) {
  2390. return retval;
  2391. }
  2393. retval = amd_create_gatt_pages(value->num_entries / 1024);
  2394. if (retval != 0) {
  2395. amd_free_page_map(&page_dir);
  2396. return retval;
  2397. }
  2399. agp_bridge.gatt_table_real = page_dir.real;
  2400. agp_bridge.gatt_table = page_dir.remapped;
  2401. agp_bridge.gatt_bus_addr = virt_to_bus(page_dir.real);
  2403. /* Get the address for the gart region.
  2404.  * This is a bus address even on the alpha, b/c its
  2405.  * used to program the agp master not the cpu
  2406.  */
  2408. pci_read_config_dword(agp_bridge.dev, AMD_APBASE, &temp);
  2409. addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  2410. agp_bridge.gart_bus_addr = addr;
  2412. /* Calculate the agp offset */
  2413. for(i = 0; i < value->num_entries / 1024; i++, addr += 0x00400000) {
  2414. page_dir.remapped[GET_PAGE_DIR_OFF(addr)] =
  2415. virt_to_bus(amd_irongate_private.gatt_pages[i]->real);
  2416. page_dir.remapped[GET_PAGE_DIR_OFF(addr)] |= 0x00000001;
  2417. }
  2419. return 0;
  2420. }
  2422. static int amd_free_gatt_table(void)
  2423. {
  2424. amd_page_map page_dir;
  2425.    
  2426. page_dir.real = agp_bridge.gatt_table_real;
  2427. page_dir.remapped = agp_bridge.gatt_table;
  2429. amd_free_gatt_pages();
  2430. amd_free_page_map(&page_dir);
  2431. return 0;
  2432. }
  2434. static int amd_irongate_fetch_size(void)
  2435. {
  2436. int i;
  2437. u32 temp;
  2438. aper_size_info_lvl2 *values;
  2440. pci_read_config_dword(agp_bridge.dev, AMD_APSIZE, &temp);
  2441. temp = (temp & 0x0000000e);
  2442. values = A_SIZE_LVL2(agp_bridge.aperture_sizes);
  2443. for (i = 0; i < agp_bridge.num_aperture_sizes; i++) {
  2444. if (temp == values[i].size_value) {
  2445. agp_bridge.previous_size =
  2446.     agp_bridge.current_size = (void *) (values + i);
  2448. agp_bridge.aperture_size_idx = i;
  2449. return values[i].size;
  2450. }
  2451. }
  2453. return 0;
  2454. }
  2456. static int amd_irongate_configure(void)
  2457. {
  2458. aper_size_info_lvl2 *current_size;
  2459. u32 temp;
  2460. u16 enable_reg;
  2462. current_size = A_SIZE_LVL2(agp_bridge.current_size);
  2464. /* Get the memory mapped registers */
  2465. pci_read_config_dword(agp_bridge.dev, AMD_MMBASE, &temp);
  2466. temp = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  2467. amd_irongate_private.registers = (volatile u8 *) ioremap(temp, 4096);
  2469. /* Write out the address of the gatt table */
  2470. OUTREG32(amd_irongate_private.registers, AMD_ATTBASE,
  2471.  agp_bridge.gatt_bus_addr);
  2473. /* Write the Sync register */
  2474. pci_write_config_byte(agp_bridge.dev, AMD_MODECNTL, 0x80);
  2475.    
  2476.     /* Set indexing mode */
  2477.     pci_write_config_byte(agp_bridge.dev, AMD_MODECNTL2, 0x00);
  2479. /* Write the enable register */
  2480. enable_reg = INREG16(amd_irongate_private.registers, AMD_GARTENABLE);
  2481. enable_reg = (enable_reg | 0x0004);
  2482. OUTREG16(amd_irongate_private.registers, AMD_GARTENABLE, enable_reg);
  2484. /* Write out the size register */
  2485. pci_read_config_dword(agp_bridge.dev, AMD_APSIZE, &temp);
  2486. temp = (((temp & ~(0x0000000e)) | current_size->size_value)
  2487. | 0x00000001);
  2488. pci_write_config_dword(agp_bridge.dev, AMD_APSIZE, temp);
  2490. /* Flush the tlb */
  2491. OUTREG32(amd_irongate_private.registers, AMD_TLBFLUSH, 0x00000001);
  2493. return 0;
  2494. }
  2496. static void amd_irongate_cleanup(void)
  2497. {
  2498. aper_size_info_lvl2 *previous_size;
  2499. u32 temp;
  2500. u16 enable_reg;
  2502. previous_size = A_SIZE_LVL2(agp_bridge.previous_size);
  2504. enable_reg = INREG16(amd_irongate_private.registers, AMD_GARTENABLE);
  2505. enable_reg = (enable_reg & ~(0x0004));
  2506. OUTREG16(amd_irongate_private.registers, AMD_GARTENABLE, enable_reg);
  2508. /* Write back the previous size and disable gart translation */
  2509. pci_read_config_dword(agp_bridge.dev, AMD_APSIZE, &temp);
  2510. temp = ((temp & ~(0x0000000f)) | previous_size->size_value);
  2511. pci_write_config_dword(agp_bridge.dev, AMD_APSIZE, temp);
  2512. iounmap((void *) amd_irongate_private.registers);
  2513. }
  2515. /*
  2516.  * This routine could be implemented by taking the addresses
  2517.  * written to the GATT, and flushing them individually.  However
  2518.  * currently it just flushes the whole table.  Which is probably
  2519.  * more efficent, since agp_memory blocks can be a large number of
  2520.  * entries.
  2521.  */
  2523. static void amd_irongate_tlbflush(agp_memory * temp)
  2524. {
  2525. OUTREG32(amd_irongate_private.registers, AMD_TLBFLUSH, 0x00000001);
  2526. }
  2528. static unsigned long amd_irongate_mask_memory(unsigned long addr, int type)
  2529. {
  2530. /* Only type 0 is supported by the irongate */
  2532. return addr | agp_bridge.masks[0].mask;
  2533. }
  2535. static int amd_insert_memory(agp_memory * mem,
  2536.      off_t pg_start, int type)
  2537. {
  2538. int i, j, num_entries;
  2539. unsigned long *cur_gatt;
  2540. unsigned long addr;
  2542. num_entries = A_SIZE_LVL2(agp_bridge.current_size)->num_entries;
  2544. if (type != 0 || mem->type != 0) {
  2545. return -EINVAL;
  2546. }
  2547. if ((pg_start + mem->page_count) > num_entries) {
  2548. return -EINVAL;
  2549. }
  2551. j = pg_start;
  2552. while (j < (pg_start + mem->page_count)) {
  2553. addr = (j * PAGE_SIZE) + agp_bridge.gart_bus_addr;
  2554. cur_gatt = GET_GATT(addr);
  2555. if (!PGE_EMPTY(cur_gatt[GET_GATT_OFF(addr)])) {
  2556. return -EBUSY;
  2557. }
  2558. j++;
  2559. }
  2561. if (mem->is_flushed == FALSE) {
  2562. CACHE_FLUSH();
  2563. mem->is_flushed = TRUE;
  2564. }
  2566. for (i = 0, j = pg_start; i < mem->page_count; i++, j++) {
  2567. addr = (j * PAGE_SIZE) + agp_bridge.gart_bus_addr;
  2568. cur_gatt = GET_GATT(addr);
  2569. cur_gatt[GET_GATT_OFF(addr)] = mem->memory[i];
  2570. }
  2571. agp_bridge.tlb_flush(mem);
  2572. return 0;
  2573. }
  2575. static int amd_remove_memory(agp_memory * mem, off_t pg_start,
  2576.      int type)
  2577. {
  2578. int i;
  2579. unsigned long *cur_gatt;
  2580. unsigned long addr;
  2582. if (type != 0 || mem->type != 0) {
  2583. return -EINVAL;
  2584. }
  2585. for (i = pg_start; i < (mem->page_count + pg_start); i++) {
  2586. addr = (i * PAGE_SIZE) + agp_bridge.gart_bus_addr;
  2587. cur_gatt = GET_GATT(addr);
  2588. cur_gatt[GET_GATT_OFF(addr)] = 
  2589. (unsigned long) agp_bridge.scratch_page;
  2590. }
  2592. agp_bridge.tlb_flush(mem);
  2593. return 0;
  2594. }
  2596. static aper_size_info_lvl2 amd_irongate_sizes[7] =
  2597. {
  2598. {2048, 524288, 0x0000000c},
  2599. {1024, 262144, 0x0000000a},
  2600. {512, 131072, 0x00000008},
  2601. {256, 65536, 0x00000006},
  2602. {128, 32768, 0x00000004},
  2603. {64, 16384, 0x00000002},
  2604. {32, 8192, 0x00000000}
  2605. };
  2607. static gatt_mask amd_irongate_masks[] =
  2608. {
  2609. {0x00000001, 0}
  2610. };
  2612. static int __init amd_irongate_setup (struct pci_dev *pdev)
  2613. {
  2614. agp_bridge.masks = amd_irongate_masks;
  2615. agp_bridge.num_of_masks = 1;
  2616. agp_bridge.aperture_sizes = (void *) amd_irongate_sizes;
  2617. agp_bridge.size_type = LVL2_APER_SIZE;
  2618. agp_bridge.num_aperture_sizes = 7;
  2619. agp_bridge.dev_private_data = (void *) &amd_irongate_private;
  2620. agp_bridge.needs_scratch_page = FALSE;
  2621. agp_bridge.configure = amd_irongate_configure;
  2622. agp_bridge.fetch_size = amd_irongate_fetch_size;
  2623. agp_bridge.cleanup = amd_irongate_cleanup;
  2624. agp_bridge.tlb_flush = amd_irongate_tlbflush;
  2625. agp_bridge.mask_memory = amd_irongate_mask_memory;
  2626. agp_bridge.agp_enable = agp_generic_agp_enable;
  2627. agp_bridge.cache_flush = global_cache_flush;
  2628. agp_bridge.create_gatt_table = amd_create_gatt_table;
  2629. agp_bridge.free_gatt_table = amd_free_gatt_table;
  2630. agp_bridge.insert_memory = amd_insert_memory;
  2631. agp_bridge.remove_memory = amd_remove_memory;
  2632. agp_bridge.alloc_by_type = agp_generic_alloc_by_type;
  2633. agp_bridge.free_by_type = agp_generic_free_by_type;
  2634. agp_bridge.agp_alloc_page = agp_generic_alloc_page;
  2635. agp_bridge.agp_destroy_page = agp_generic_destroy_page;
  2636. agp_bridge.suspend = agp_generic_suspend;
  2637. agp_bridge.resume = agp_generic_resume;
  2638. agp_bridge.cant_use_aperture = 0;
  2640. return 0;
  2642. (void) pdev; /* unused */
  2643. }
  2645. #endif /* CONFIG_AGP_AMD */
  2647. #ifdef CONFIG_AGP_ALI
  2649. static int ali_fetch_size(void)
  2650. {
  2651. int i;
  2652. u32 temp;
  2653. aper_size_info_32 *values;
  2655. pci_read_config_dword(agp_bridge.dev, ALI_ATTBASE, &temp);
  2656. temp &= ~(0xfffffff0);
  2657. values = A_SIZE_32(agp_bridge.aperture_sizes);
  2659. for (i = 0; i < agp_bridge.num_aperture_sizes; i++) {
  2660. if (temp == values[i].size_value) {
  2661. agp_bridge.previous_size =
  2662.     agp_bridge.current_size = (void *) (values + i);
  2663. agp_bridge.aperture_size_idx = i;
  2664. return values[i].size;
  2665. }
  2666. }
  2668. return 0;
  2669. }
  2671. static void ali_tlbflush(agp_memory * mem)
  2672. {
  2673. u32 temp;
  2675. pci_read_config_dword(agp_bridge.dev, ALI_TLBCTRL, &temp);
  2676. // clear tag
  2677. pci_write_config_dword(agp_bridge.dev, ALI_TAGCTRL,
  2678. ((temp & 0xfffffff0) | 0x00000001|0x00000002));
  2679. }
  2681. static void ali_cleanup(void)
  2682. {
  2683. aper_size_info_32 *previous_size;
  2684. u32 temp;
  2686. previous_size = A_SIZE_32(agp_bridge.previous_size);
  2688. pci_read_config_dword(agp_bridge.dev, ALI_TLBCTRL, &temp);
  2689. // clear tag
  2690. pci_write_config_dword(agp_bridge.dev, ALI_TAGCTRL,
  2691. ((temp & 0xffffff00) | 0x00000001|0x00000002));
  2693. pci_read_config_dword(agp_bridge.dev,  ALI_ATTBASE, &temp);
  2694. pci_write_config_dword(agp_bridge.dev, ALI_ATTBASE,
  2695. ((temp & 0x00000ff0) | previous_size->size_value));
  2696. }
  2698. static int ali_configure(void)
  2699. {
  2700. u32 temp;
  2701. aper_size_info_32 *current_size;
  2703. current_size = A_SIZE_32(agp_bridge.current_size);
  2705. /* aperture size and gatt addr */
  2706. pci_read_config_dword(agp_bridge.dev, ALI_ATTBASE, &temp);
  2707. temp = (((temp & 0x00000ff0) | (agp_bridge.gatt_bus_addr & 0xfffff000))
  2708. | (current_size->size_value & 0xf));
  2709. pci_write_config_dword(agp_bridge.dev, ALI_ATTBASE, temp);
  2711. /* tlb control */
  2713. /*
  2714.  * Question: Jeff, ALi's patch deletes this:
  2715.  *
  2716.  * pci_read_config_dword(agp_bridge.dev, ALI_TLBCTRL, &temp);
  2717.  * pci_write_config_dword(agp_bridge.dev, ALI_TLBCTRL,
  2718.  *        ((temp & 0xffffff00) | 0x00000010));
  2719.  *
  2720.  * and replaces it with the following, which seems to duplicate the
  2721.  * next couple of lines below it. I suspect this was an oversight,
  2722.  * but you might want to check up on this?
  2723.  */
  2725. pci_read_config_dword(agp_bridge.dev, ALI_APBASE, &temp);
  2726. agp_bridge.gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  2728. /* address to map to */
  2729. pci_read_config_dword(agp_bridge.dev, ALI_APBASE, &temp);
  2730. agp_bridge.gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  2732. #if 0
  2733. if (agp_bridge.type == ALI_M1541) {
  2734. u32 nlvm_addr = 0;
  2736. switch (current_size->size_value) {
  2737. case 0:  break;
  2738. case 1:  nlvm_addr = 0x100000;break;
  2739. case 2:  nlvm_addr = 0x200000;break;
  2740. case 3:  nlvm_addr = 0x400000;break;
  2741. case 4:  nlvm_addr = 0x800000;break;
  2742. case 6:  nlvm_addr = 0x1000000;break;
  2743. case 7:  nlvm_addr = 0x2000000;break;
  2744. case 8:  nlvm_addr = 0x4000000;break;
  2745. case 9:  nlvm_addr = 0x8000000;break;
  2746. case 10: nlvm_addr = 0x10000000;break;
  2747. default: break;
  2748. }
  2749. nlvm_addr--;
  2750. nlvm_addr&=0xfff00000;
  2752. nlvm_addr+= agp_bridge.gart_bus_addr;
  2753. nlvm_addr|=(agp_bridge.gart_bus_addr>>12);
  2754. printk(KERN_INFO PFX "nlvm top &base = %8xn",nlvm_addr);
  2755. }
  2756. #endif
  2758. pci_read_config_dword(agp_bridge.dev, ALI_TLBCTRL, &temp);
  2759. temp &= 0xffffff7f; //enable TLB
  2760. pci_write_config_dword(agp_bridge.dev, ALI_TLBCTRL, temp);
  2762. return 0;
  2763. }
  2765. static unsigned long ali_mask_memory(unsigned long addr, int type)
  2766. {
  2767. /* Memory type is ignored */
  2769. return addr | agp_bridge.masks[0].mask;
  2770. }
  2772. static void ali_cache_flush(void)
  2773. {
  2774. global_cache_flush();
  2776. if (agp_bridge.type == ALI_M1541) {
  2777. int i, page_count;
  2778. u32 temp;
  2780. page_count = 1 << A_SIZE_32(agp_bridge.current_size)->page_order;
  2781. for (i = 0; i < PAGE_SIZE * page_count; i += PAGE_SIZE) {
  2782. pci_read_config_dword(agp_bridge.dev, ALI_CACHE_FLUSH_CTRL, &temp);
  2783. pci_write_config_dword(agp_bridge.dev, ALI_CACHE_FLUSH_CTRL,
  2784. (((temp & ALI_CACHE_FLUSH_ADDR_MASK) |
  2785.   (agp_bridge.gatt_bus_addr + i)) |
  2786.     ALI_CACHE_FLUSH_EN));
  2787. }
  2788. }
  2789. }
  2791. static unsigned long ali_alloc_page(void)
  2792. {
  2793. struct page *page;
  2794. u32 temp;
  2796. page = alloc_page(GFP_KERNEL);
  2797. if (page == NULL)
  2798. return 0;
  2800. atomic_inc(&page->count);
  2801. set_bit(PG_locked, &page->flags);
  2802. atomic_inc(&agp_bridge.current_memory_agp);
  2804. global_cache_flush();
  2806. if (agp_bridge.type == ALI_M1541) {
  2807. pci_read_config_dword(agp_bridge.dev, ALI_CACHE_FLUSH_CTRL, &temp);
  2808. pci_write_config_dword(agp_bridge.dev, ALI_CACHE_FLUSH_CTRL,
  2809. (((temp & ALI_CACHE_FLUSH_ADDR_MASK) |
  2810.   virt_to_phys(page_address(page))) |
  2811.     ALI_CACHE_FLUSH_EN ));
  2812. }
  2813. return (unsigned long)page_address(page);
  2814. }
  2816. static void ali_destroy_page(unsigned long addr)
  2817. {
  2818. u32 temp;
  2819. void *pt = (void *) addr;
  2820. struct page *page;
  2822. if (pt == NULL)
  2823. return;
  2825. global_cache_flush();
  2827. if (agp_bridge.type == ALI_M1541) {
  2828. pci_read_config_dword(agp_bridge.dev, ALI_CACHE_FLUSH_CTRL, &temp);
  2829. pci_write_config_dword(agp_bridge.dev, ALI_CACHE_FLUSH_CTRL,
  2830. (((temp & ALI_CACHE_FLUSH_ADDR_MASK) |
  2831.   virt_to_phys((void *)pt)) |
  2832.     ALI_CACHE_FLUSH_EN));
  2833. }
  2835. page = virt_to_page(pt);
  2836. atomic_dec(&page->count);
  2837. clear_bit(PG_locked, &page->flags);
  2838. wake_up(&page->wait);
  2839. free_page((unsigned long) pt);
  2840. atomic_dec(&agp_bridge.current_memory_agp);
  2841. }
  2843. /* Setup function */
  2844. static gatt_mask ali_generic_masks[] =
  2845. {
  2846. {0x00000000, 0}
  2847. };
  2849. static aper_size_info_32 ali_generic_sizes[7] =
  2850. {
  2851. {256, 65536, 6, 10},
  2852. {128, 32768, 5, 9},
  2853. {64, 16384, 4, 8},
  2854. {32, 8192, 3, 7},
  2855. {16, 4096, 2, 6},
  2856. {8, 2048, 1, 4},
  2857. {4, 1024, 0, 3}
  2858. };
  2860. static int __init ali_generic_setup (struct pci_dev *pdev)
  2861. {
  2862. agp_bridge.masks = ali_generic_masks;
  2863. agp_bridge.num_of_masks = 1;
  2864. agp_bridge.aperture_sizes = (void *) ali_generic_sizes;
  2865. agp_bridge.size_type = U32_APER_SIZE;
  2866. agp_bridge.num_aperture_sizes = 7;
  2867. agp_bridge.dev_private_data = NULL;
  2868. agp_bridge.needs_scratch_page = FALSE;
  2869. agp_bridge.configure = ali_configure;
  2870. agp_bridge.fetch_size = ali_fetch_size;
  2871. agp_bridge.cleanup = ali_cleanup;
  2872. agp_bridge.tlb_flush = ali_tlbflush;
  2873. agp_bridge.mask_memory = ali_mask_memory;
  2874. agp_bridge.agp_enable = agp_generic_agp_enable;
  2875. agp_bridge.cache_flush = ali_cache_flush;
  2876. agp_bridge.create_gatt_table = agp_generic_create_gatt_table;
  2877. agp_bridge.free_gatt_table = agp_generic_free_gatt_table;
  2878. agp_bridge.insert_memory = agp_generic_insert_memory;
  2879. agp_bridge.remove_memory = agp_generic_remove_memory;
  2880. agp_bridge.alloc_by_type = agp_generic_alloc_by_type;
  2881. agp_bridge.free_by_type = agp_generic_free_by_type;
  2882. agp_bridge.agp_alloc_page = ali_alloc_page;
  2883. agp_bridge.agp_destroy_page = ali_destroy_page;
  2884. agp_bridge.suspend = agp_generic_suspend;
  2885. agp_bridge.resume = agp_generic_resume;
  2886. agp_bridge.cant_use_aperture = 0;
  2888. return 0;
  2890. (void) pdev; /* unused */
  2891. }
  2893. #endif /* CONFIG_AGP_ALI */
  2895. #ifdef CONFIG_AGP_SWORKS
  2896. typedef struct _serverworks_page_map {
  2897. unsigned long *real;
  2898. unsigned long *remapped;
  2899. } serverworks_page_map;
  2901. static struct _serverworks_private {
  2902. struct pci_dev *svrwrks_dev; /* device one */
  2903. volatile u8 *registers;
  2904. serverworks_page_map **gatt_pages;
  2905. int num_tables;
  2906. serverworks_page_map scratch_dir;
  2908. int gart_addr_ofs;
  2909. int mm_addr_ofs;
  2910. } serverworks_private;
  2912. static int serverworks_create_page_map(serverworks_page_map *page_map)
  2913. {
  2914. int i;
  2916. page_map->real = (unsigned long *) __get_free_page(GFP_KERNEL);
  2917. if (page_map->real == NULL) {
  2918. return -ENOMEM;
  2919. }
  2920. set_bit(PG_reserved, &virt_to_page(page_map->real)->flags);
  2921. CACHE_FLUSH();
  2922. page_map->remapped = ioremap_nocache(virt_to_phys(page_map->real), 
  2923.     PAGE_SIZE);
  2924. if (page_map->remapped == NULL) {
  2925. clear_bit(PG_reserved, 
  2926.   &virt_to_page(page_map->real)->flags);
  2927. free_page((unsigned long) page_map->real);
  2928. page_map->real = NULL;
  2929. return -ENOMEM;
  2930. }
  2931. CACHE_FLUSH();
  2933. for(i = 0; i < PAGE_SIZE / sizeof(unsigned long); i++) {
  2934. page_map->remapped[i] = agp_bridge.scratch_page;
  2935. }
  2937. return 0;
  2938. }
  2940. static void serverworks_free_page_map(serverworks_page_map *page_map)
  2941. {
  2942. iounmap(page_map->remapped);
  2943. clear_bit(PG_reserved, 
  2944.   &virt_to_page(page_map->real)->flags);
  2945. free_page((unsigned long) page_map->real);
  2946. }
  2948. static void serverworks_free_gatt_pages(void)
  2949. {
  2950. int i;
  2951. serverworks_page_map **tables;
  2952. serverworks_page_map *entry;
  2954. tables = serverworks_private.gatt_pages;
  2955. for(i = 0; i < serverworks_private.num_tables; i++) {
  2956. entry = tables[i];
  2957. if (entry != NULL) {
  2958. if (entry->real != NULL) {
  2959. serverworks_free_page_map(entry);
  2960. }
  2961. kfree(entry);
  2962. }
  2963. }
  2964. kfree(tables);
  2965. }
  2967. static int serverworks_create_gatt_pages(int nr_tables)
  2968. {
  2969. serverworks_page_map **tables;
  2970. serverworks_page_map *entry;
  2971. int retval = 0;
  2972. int i;
  2974. tables = kmalloc((nr_tables + 1) * sizeof(serverworks_page_map *), 
  2975.  GFP_KERNEL);
  2976. if (tables == NULL) {
  2977. return -ENOMEM;
  2978. }
  2979. memset(tables, 0, sizeof(serverworks_page_map *) * (nr_tables + 1));
  2980. for (i = 0; i < nr_tables; i++) {
  2981. entry = kmalloc(sizeof(serverworks_page_map), GFP_KERNEL);
  2982. if (entry == NULL) {
  2983. retval = -ENOMEM;
  2984. break;
  2985. }
  2986. memset(entry, 0, sizeof(serverworks_page_map));
  2987. tables[i] = entry;
  2988. retval = serverworks_create_page_map(entry);
  2989. if (retval != 0) break;
  2990. }
  2991. serverworks_private.num_tables = nr_tables;
  2992. serverworks_private.gatt_pages = tables;
  2994. if (retval != 0) serverworks_free_gatt_pages();
  2996. return retval;
  2997. }
  2999. #define SVRWRKS_GET_GATT(addr) (serverworks_private.gatt_pages[
  3000. GET_PAGE_DIR_IDX(addr)]->remapped)
  3002. #ifndef GET_PAGE_DIR_OFF
  3003. #define GET_PAGE_DIR_OFF(addr) (addr >> 22)
  3004. #endif
  3006. #ifndef GET_PAGE_DIR_IDX
  3007. #define GET_PAGE_DIR_IDX(addr) (GET_PAGE_DIR_OFF(addr) - 
  3008. GET_PAGE_DIR_OFF(agp_bridge.gart_bus_addr))
  3009. #endif
  3011. #ifndef GET_GATT_OFF
  3012. #define GET_GATT_OFF(addr) ((addr & 0x003ff000) >> 12)
  3013. #endif
  3015. static int serverworks_create_gatt_table(void)
  3016. {
  3017. aper_size_info_lvl2 *value;
  3018. serverworks_page_map page_dir;
  3019. int retval;
  3020. u32 temp;
  3021. int i;
  3023. value = A_SIZE_LVL2(agp_bridge.current_size);
  3024. retval = serverworks_create_page_map(&page_dir);
  3025. if (retval != 0) {
  3026. return retval;
  3027. }
  3028. retval = serverworks_create_page_map(&serverworks_private.scratch_dir);
  3029. if (retval != 0) {
  3030. serverworks_free_page_map(&page_dir);
  3031. return retval;
  3032. }
  3033. /* Create a fake scratch directory */
  3034. for(i = 0; i < 1024; i++) {
  3035. serverworks_private.scratch_dir.remapped[i] = (unsigned long) agp_bridge.scratch_page;
  3036. page_dir.remapped[i] =
  3037. virt_to_bus(serverworks_private.scratch_dir.real);
  3038. page_dir.remapped[i] |= 0x00000001;
  3039. }
  3041. retval = serverworks_create_gatt_pages(value->num_entries / 1024);
  3042. if (retval != 0) {
  3043. serverworks_free_page_map(&page_dir);
  3044. serverworks_free_page_map(&serverworks_private.scratch_dir);
  3045. return retval;
  3046. }
  3048. agp_bridge.gatt_table_real = page_dir.real;
  3049. agp_bridge.gatt_table = page_dir.remapped;
  3050. agp_bridge.gatt_bus_addr = virt_to_bus(page_dir.real);
  3052. /* Get the address for the gart region.
  3053.  * This is a bus address even on the alpha, b/c its
  3054.  * used to program the agp master not the cpu
  3055.  */
  3057. pci_read_config_dword(agp_bridge.dev,
  3058.       serverworks_private.gart_addr_ofs,
  3059.       &temp);
  3060. agp_bridge.gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  3062. /* Calculate the agp offset */
  3064. for(i = 0; i < value->num_entries / 1024; i++) {
  3065. page_dir.remapped[i] =
  3066. virt_to_bus(serverworks_private.gatt_pages[i]->real);
  3067. page_dir.remapped[i] |= 0x00000001;
  3068. }
  3070. return 0;
  3071. }
  3073. static int serverworks_free_gatt_table(void)
  3074. {
  3075. serverworks_page_map page_dir;
  3076.    
  3077. page_dir.real = agp_bridge.gatt_table_real;
  3078. page_dir.remapped = agp_bridge.gatt_table;
  3080. serverworks_free_gatt_pages();
  3081. serverworks_free_page_map(&page_dir);
  3082. serverworks_free_page_map(&serverworks_private.scratch_dir);
  3083. return 0;
  3084. }
  3086. static int serverworks_fetch_size(void)
  3087. {
  3088. int i;
  3089. u32 temp;
  3090. u32 temp2;
  3091. aper_size_info_lvl2 *values;
  3093. values = A_SIZE_LVL2(agp_bridge.aperture_sizes);
  3094. pci_read_config_dword(agp_bridge.dev,
  3095.       serverworks_private.gart_addr_ofs,
  3096.       &temp);
  3097. pci_write_config_dword(agp_bridge.dev,
  3098.        serverworks_private.gart_addr_ofs,
  3099.        SVWRKS_SIZE_MASK);
  3100. pci_read_config_dword(agp_bridge.dev,
  3101.       serverworks_private.gart_addr_ofs,
  3102.       &temp2);
  3103. pci_write_config_dword(agp_bridge.dev,
  3104.        serverworks_private.gart_addr_ofs,
  3105.        temp);
  3106. temp2 &= SVWRKS_SIZE_MASK;
  3108. for (i = 0; i < agp_bridge.num_aperture_sizes; i++) {
  3109. if (temp2 == values[i].size_value) {
  3110. agp_bridge.previous_size =
  3111.     agp_bridge.current_size = (void *) (values + i);
  3113. agp_bridge.aperture_size_idx = i;
  3114. return values[i].size;
  3115. }
  3116. }
  3118. return 0;
  3119. }
  3121. static int serverworks_configure(void)
  3122. {
  3123. aper_size_info_lvl2 *current_size;
  3124. u32 temp;
  3125. u8 enable_reg;
  3126. u8 cap_ptr;
  3127. u32 cap_id;
  3128. u16 cap_reg;
  3130. current_size = A_SIZE_LVL2(agp_bridge.current_size);
  3132. /* Get the memory mapped registers */
  3133. pci_read_config_dword(agp_bridge.dev,
  3134.       serverworks_private.mm_addr_ofs,
  3135.       &temp);
  3136. temp = (temp & PCI_BASE_ADDRESS_MEM_MASK);
  3137. serverworks_private.registers = (volatile u8 *) ioremap(temp, 4096);
  3139. OUTREG8(serverworks_private.registers, SVWRKS_GART_CACHE, 0x0a);
  3141. OUTREG32(serverworks_private.registers, SVWRKS_GATTBASE, 
  3142.  agp_bridge.gatt_bus_addr);
  3144. cap_reg = INREG16(serverworks_private.registers, SVWRKS_COMMAND);
  3145. cap_reg &= ~0x0007;
  3146. cap_reg |= 0x4;
  3147. OUTREG16(serverworks_private.registers, SVWRKS_COMMAND, cap_reg);
  3149. pci_read_config_byte(serverworks_private.svrwrks_dev,
  3150.      SVWRKS_AGP_ENABLE, &enable_reg);
  3151. enable_reg |= 0x1; /* Agp Enable bit */
  3152. pci_write_config_byte(serverworks_private.svrwrks_dev,
  3153.       SVWRKS_AGP_ENABLE, enable_reg);
  3154. agp_bridge.tlb_flush(NULL);
  3156. pci_read_config_byte(serverworks_private.svrwrks_dev, 0x34, &cap_ptr);
  3157. if (cap_ptr != 0x00) {
  3158. do {
  3159. pci_read_config_dword(serverworks_private.svrwrks_dev,
  3160.       cap_ptr, &cap_id);
  3162. if ((cap_id & 0xff) != 0x02)
  3163. cap_ptr = (cap_id >> 8) & 0xff;
  3164. }
  3165. while (((cap_id & 0xff) != 0x02) && (cap_ptr != 0x00));
  3166. }
  3167. agp_bridge.capndx = cap_ptr;
  3169. /* Fill in the mode register */
  3170. pci_read_config_dword(serverworks_private.svrwrks_dev,
  3171.       agp_bridge.capndx + 4,
  3172.       &agp_bridge.mode);
  3174. pci_read_config_byte(agp_bridge.dev,
  3175.      SVWRKS_CACHING,
  3176.      &enable_reg);
  3177. enable_reg &= ~0x3;
  3178. pci_write_config_byte(agp_bridge.dev,
  3179.       SVWRKS_CACHING,
  3180.       enable_reg);
  3182. pci_read_config_byte(agp_bridge.dev,
  3183.      SVWRKS_FEATURE,
  3184.      &enable_reg);
  3185. enable_reg |= (1<<6);
  3186. pci_write_config_byte(agp_bridge.dev,
  3187.       SVWRKS_FEATURE,
  3188.       enable_reg);
  3190. return 0;
  3191. }
  3193. static void serverworks_cleanup(void)
  3194. {
  3195. iounmap((void *) serverworks_private.registers);
  3196. }
  3198. /*
  3199.  * This routine could be implemented by taking the addresses
  3200.  * written to the GATT, and flushing them individually.  However
  3201.  * currently it just flushes the whole table.  Which is probably
  3202.  * more efficent, since agp_memory blocks can be a large number of
  3203.  * entries.
  3204.  */
  3206. static void serverworks_tlbflush(agp_memory * temp)
  3207. {
  3208. unsigned long end;
  3210. OUTREG8(serverworks_private.registers, SVWRKS_POSTFLUSH, 0x01);
  3211. end = jiffies + 3*HZ;
  3212. while(INREG8(serverworks_private.registers, 
  3213.      SVWRKS_POSTFLUSH) == 0x01) {
  3214. if((signed)(end - jiffies) <= 0) {
  3215. printk(KERN_ERR "Posted write buffer flush took more"
  3216.        "then 3 secondsn");
  3217. }
  3218. }
  3219. OUTREG32(serverworks_private.registers, SVWRKS_DIRFLUSH, 0x00000001);
  3220. end = jiffies + 3*HZ;
  3221. while(INREG32(serverworks_private.registers, 
  3222.      SVWRKS_DIRFLUSH) == 0x00000001) {
  3223. if((signed)(end - jiffies) <= 0) {
  3224. printk(KERN_ERR "TLB flush took more"
  3225.        "then 3 secondsn");
  3226. }
  3227. }
  3228. }
  3230. static unsigned long serverworks_mask_memory(unsigned long addr, int type)
  3231. {
  3232. /* Only type 0 is supported by the serverworks chipsets */
  3234. return addr | agp_bridge.masks[0].mask;
  3235. }
  3237. static int serverworks_insert_memory(agp_memory * mem,
  3238.      off_t pg_start, int type)
  3239. {
  3240. int i, j, num_entries;
  3241. unsigned long *cur_gatt;
  3242. unsigned long addr;
  3244. num_entries = A_SIZE_LVL2(agp_bridge.current_size)->num_entries;
  3246. if (type != 0 || mem->type != 0) {
  3247. return -EINVAL;
  3248. }
  3249. if ((pg_start + mem->page_count) > num_entries) {
  3250. return -EINVAL;
  3251. }
  3253. j = pg_start;
  3254. while (j < (pg_start + mem->page_count)) {
  3255. addr = (j * PAGE_SIZE) + agp_bridge.gart_bus_addr;
  3256. cur_gatt = SVRWRKS_GET_GATT(addr);
  3257. if (!PGE_EMPTY(cur_gatt[GET_GATT_OFF(addr)])) {
  3258. return -EBUSY;
  3259. }
  3260. j++;
  3261. }
  3263. if (mem->is_flushed == FALSE) {
  3264. CACHE_FLUSH();
  3265. mem->is_flushed = TRUE;
  3266. }
  3268. for (i = 0, j = pg_start; i < mem->page_count; i++, j++) {
  3269. addr = (j * PAGE_SIZE) + agp_bridge.gart_bus_addr;
  3270. cur_gatt = SVRWRKS_GET_GATT(addr);
  3271. cur_gatt[GET_GATT_OFF(addr)] = mem->memory[i];
  3272. }
  3273. agp_bridge.tlb_flush(mem);
  3274. return 0;
  3275. }
  3277. static int serverworks_remove_memory(agp_memory * mem, off_t pg_start,
  3278.      int type)
  3279. {
  3280. int i;
  3281. unsigned long *cur_gatt;
  3282. unsigned long addr;
  3284. if (type != 0 || mem->type != 0) {
  3285. return -EINVAL;
  3286. }
  3288. CACHE_FLUSH();
  3289. agp_bridge.tlb_flush(mem);
  3291. for (i = pg_start; i < (mem->page_count + pg_start); i++) {
  3292. addr = (i * PAGE_SIZE) + agp_bridge.gart_bus_addr;
  3293. cur_gatt = SVRWRKS_GET_GATT(addr);
  3294. cur_gatt[GET_GATT_OFF(addr)] = 
  3295. (unsigned long) agp_bridge.scratch_page;
  3296. }
  3298. agp_bridge.tlb_flush(mem);
  3299. return 0;
  3300. }
  3302. static gatt_mask serverworks_masks[] =
  3303. {
  3304. {0x00000001, 0}
  3305. };
  3307. static aper_size_info_lvl2 serverworks_sizes[7] =
  3308. {
  3309. {2048, 524288, 0x80000000},
  3310. {1024, 262144, 0xc0000000},
  3311. {512, 131072, 0xe0000000},
  3312. {256, 65536, 0xf0000000},
  3313. {128, 32768, 0xf8000000},
  3314. {64, 16384, 0xfc000000},
  3315. {32, 8192, 0xfe000000}
  3316. };
  3318. static void serverworks_agp_enable(u32 mode)
  3319. {
  3320. struct pci_dev *device = NULL;
  3321. u32 command, scratch, cap_id;
  3322. u8 cap_ptr;
  3324. pci_read_config_dword(serverworks_private.svrwrks_dev,
  3325.       agp_bridge.capndx + 4,
  3326.       &command);
  3328. /*
  3329.  * PASS1: go throu all devices that claim to be
  3330.  *        AGP devices and collect their data.
  3331.  */
  3334. pci_for_each_dev(device)
  3335. {
  3336. /*
  3337.  * Enable AGP devices. Most will be VGA display but
  3338.  * some may be coprocessors on non VGA devices too
  3339.  */
  3340.  
  3341. if((((device->class >> 16) & 0xFF) != PCI_BASE_CLASS_DISPLAY) &&
  3342. (device->class != (PCI_CLASS_PROCESSOR_CO << 8)))
  3343. continue;
  3345. pci_read_config_dword(device, 0x04, &scratch);
  3347. if (!(scratch & 0x00100000))
  3348. continue;
  3350. pci_read_config_byte(device, 0x34, &cap_ptr);
  3352. if (cap_ptr != 0x00) {
  3353. do {
  3354. pci_read_config_dword(device,
  3355.       cap_ptr, &cap_id);
  3357. if ((cap_id & 0xff) != 0x02)
  3358. cap_ptr = (cap_id >> 8) & 0xff;
  3359. }
  3360. while (((cap_id & 0xff) != 0x02) && (cap_ptr != 0x00));
  3361. }
  3362. if (cap_ptr != 0x00) {
  3363. /*
  3364.  * Ok, here we have a AGP device. Disable impossible 
  3365.  * settings, and adjust the readqueue to the minimum.
  3366.  */
  3368. pci_read_config_dword(device, cap_ptr + 4, &scratch);
  3370. /* adjust RQ depth */
  3371. command =
  3372.     ((command & ~0xff000000) |
  3373.      min_t(u32, (mode & 0xff000000),
  3374.  min_t(u32, (command & 0xff000000),
  3375.      (scratch & 0xff000000))));
  3377. /* disable SBA if it's not supported */
  3378. if (!((command & 0x00000200) &&
  3379.       (scratch & 0x00000200) &&
  3380.       (mode & 0x00000200)))
  3381. command &= ~0x00000200;
  3383. /* disable FW */
  3384. command &= ~0x00000010;
  3386. command &= ~0x00000008;
  3388. if (!((command & 4) &&
  3389.       (scratch & 4) &&
  3390.       (mode & 4)))
  3391. command &= ~0x00000004;
  3393. if (!((command & 2) &&
  3394.       (scratch & 2) &&
  3395.       (mode & 2)))
  3396. command &= ~0x00000002;
  3398. if (!((command & 1) &&
  3399.       (scratch & 1) &&
  3400.       (mode & 1)))
  3401. command &= ~0x00000001;
  3402. }
  3403. }
  3404. /*
  3405.  * PASS2: Figure out the 4X/2X/1X setting and enable the
  3406.  *        target (our motherboard chipset).
  3407.  */
  3409. if (command & 4) {
  3410. command &= ~3; /* 4X */
  3411. }
  3412. if (command & 2) {
  3413. command &= ~5; /* 2X */
  3414. }
  3415. if (command & 1) {
  3416. command &= ~6; /* 1X */
  3417. }
  3418. command |= 0x00000100;
  3420. pci_write_config_dword(serverworks_private.svrwrks_dev,
  3421.        agp_bridge.capndx + 8,
  3422.        command);
  3424. /*
  3425.  * PASS3: Go throu all AGP devices and update the
  3426.  *        command registers.
  3427.  */
  3429. while ((device = pci_find_class(PCI_CLASS_DISPLAY_VGA << 8,
  3430. device)) != NULL) {
  3431. pci_read_config_dword(device, 0x04, &scratch);
  3433. if (!(scratch & 0x00100000))
  3434. continue;
  3436. pci_read_config_byte(device, 0x34, &cap_ptr);
  3438. if (cap_ptr != 0x00) {
  3439. do {
  3440. pci_read_config_dword(device,
  3441.       cap_ptr, &cap_id);
  3443. if ((cap_id & 0xff) != 0x02)
  3444. cap_ptr = (cap_id >> 8) & 0xff;
  3445. }
  3446. while (((cap_id & 0xff) != 0x02) && (cap_ptr != 0x00));
  3447. }
  3448. if (cap_ptr != 0x00)
  3449. pci_write_config_dword(device, cap_ptr + 8, command);
  3450. }
  3451. }
  3453. static int __init serverworks_setup (struct pci_dev *pdev)
  3454. {
  3455. u32 temp;
  3456. u32 temp2;
  3458. serverworks_private.svrwrks_dev = pdev;
  3460. agp_bridge.masks = serverworks_masks;
  3461. agp_bridge.num_of_masks = 1;
  3462. agp_bridge.aperture_sizes = (void *) serverworks_sizes;
  3463. agp_bridge.size_type = LVL2_APER_SIZE;
  3464. agp_bridge.num_aperture_sizes = 7;
  3465. agp_bridge.dev_private_data = (void *) &serverworks_private;
  3466. agp_bridge.needs_scratch_page = TRUE;
  3467. agp_bridge.configure = serverworks_configure;
  3468. agp_bridge.fetch_size = serverworks_fetch_size;
  3469. agp_bridge.cleanup = serverworks_cleanup;
  3470. agp_bridge.tlb_flush = serverworks_tlbflush;
  3471. agp_bridge.mask_memory = serverworks_mask_memory;
  3472. agp_bridge.agp_enable = serverworks_agp_enable;
  3473. agp_bridge.cache_flush = global_cache_flush;
  3474. agp_bridge.create_gatt_table = serverworks_create_gatt_table;
  3475. agp_bridge.free_gatt_table = serverworks_free_gatt_table;
  3476. agp_bridge.insert_memory = serverworks_insert_memory;
  3477. agp_bridge.remove_memory = serverworks_remove_memory;
  3478. agp_bridge.alloc_by_type = agp_generic_alloc_by_type;
  3479. agp_bridge.free_by_type = agp_generic_free_by_type;
  3480. agp_bridge.agp_alloc_page = agp_generic_alloc_page;
  3481. agp_bridge.agp_destroy_page = agp_generic_destroy_page;
  3482. agp_bridge.suspend = agp_generic_suspend;
  3483. agp_bridge.resume = agp_generic_resume;
  3484. agp_bridge.cant_use_aperture = 0;
  3486. pci_read_config_dword(agp_bridge.dev,
  3487.       SVWRKS_APSIZE,
  3488.       &temp);
  3490. serverworks_private.gart_addr_ofs = 0x10;
  3492. if(temp & PCI_BASE_ADDRESS_MEM_TYPE_64) {
  3493. pci_read_config_dword(agp_bridge.dev,
  3494.       SVWRKS_APSIZE + 4,
  3495.       &temp2);
  3496. if(temp2 != 0) {
  3497. printk("Detected 64 bit aperture address, but top "
  3498.        "bits are not zero.  Disabling agpn");
  3499. return -ENODEV;
  3500. }
  3501. serverworks_private.mm_addr_ofs = 0x18;
  3502. } else {
  3503. serverworks_private.mm_addr_ofs = 0x14;
  3504. }
  3506. pci_read_config_dword(agp_bridge.dev,
  3507.       serverworks_private.mm_addr_ofs,
  3508.       &temp);
  3509. if(temp & PCI_BASE_ADDRESS_MEM_TYPE_64) {
  3510. pci_read_config_dword(agp_bridge.dev,
  3511.       serverworks_private.mm_addr_ofs + 4,
  3512.       &temp2);
  3513. if(temp2 != 0) {
  3514. printk("Detected 64 bit MMIO address, but top "
  3515.        "bits are not zero.  Disabling agpn");
  3516. return -ENODEV;
  3517. }
  3518. }
  3520. return 0;
  3521. }
  3523. #endif /* CONFIG_AGP_SWORKS */
  3526. /* per-chipset initialization data.
  3527.  * note -- all chipsets for a single vendor MUST be grouped together
  3528.  */
  3529. static struct {
  3530. unsigned short device_id; /* first, to make table easier to read */
  3531. unsigned short vendor_id;
  3532. enum chipset_type chipset;
  3533. const char *vendor_name;
  3534. const char *chipset_name;
  3535. int (*chipset_setup) (struct pci_dev *pdev);
  3536. } agp_bridge_info[] __initdata = {
  3538. #ifdef CONFIG_AGP_ALI
  3539. { PCI_DEVICE_ID_AL_M1541_0,
  3540. PCI_VENDOR_ID_AL,
  3541. ALI_M1541,
  3542. "Ali",
  3543. "M1541",
  3544. ali_generic_setup },
  3545. { PCI_DEVICE_ID_AL_M1621_0,  
  3546. PCI_VENDOR_ID_AL,
  3547. ALI_M1621,
  3548. "Ali",
  3549. "M1621",
  3550. ali_generic_setup },
  3551. { PCI_DEVICE_ID_AL_M1631_0,
  3552. PCI_VENDOR_ID_AL,
  3553. ALI_M1631,
  3554. "Ali",
  3555. "M1631",
  3556. ali_generic_setup },
  3557. { PCI_DEVICE_ID_AL_M1632_0,
  3558. PCI_VENDOR_ID_AL,
  3559. ALI_M1632,
  3560. "Ali",
  3561. "M1632",
  3562. ali_generic_setup },
  3563. { PCI_DEVICE_ID_AL_M1641_0,
  3564. PCI_VENDOR_ID_AL,
  3565. ALI_M1641,
  3566. "Ali",
  3567. "M1641",
  3568. ali_generic_setup },
  3569. { PCI_DEVICE_ID_AL_M1647_0,
  3570. PCI_VENDOR_ID_AL,
  3571. ALI_M1647,
  3572. "Ali",
  3573. "M1647",
  3574. ali_generic_setup },
  3575. { PCI_DEVICE_ID_AL_M1651_0,
  3576. PCI_VENDOR_ID_AL,
  3577. ALI_M1651,
  3578. "Ali",
  3579. "M1651",
  3580. ali_generic_setup },  
  3581. { 0,
  3582. PCI_VENDOR_ID_AL,
  3583. ALI_GENERIC,
  3584. "Ali",
  3585. "Generic",
  3586. ali_generic_setup },
  3587. #endif /* CONFIG_AGP_ALI */
  3589. #ifdef CONFIG_AGP_AMD
  3590. { PCI_DEVICE_ID_AMD_IRONGATE_0,
  3591. PCI_VENDOR_ID_AMD,
  3592. AMD_IRONGATE,
  3593. "AMD",
  3594. "Irongate",
  3595. amd_irongate_setup },
  3596. { PCI_DEVICE_ID_AMD_762_0,
  3597. PCI_VENDOR_ID_AMD,
  3598. AMD_IRONGATE,
  3599. "AMD",
  3600. "AMD 760MP",
  3601. amd_irongate_setup },
  3602. { PCI_DEVICE_ID_AMD_761_0,
  3603. PCI_VENDOR_ID_AMD,
  3604. AMD_761,
  3605. "AMD",
  3606. "761",
  3607. amd_irongate_setup },
  3608. { PCI_DEVICE_ID_AMD_762_0,
  3609. PCI_VENDOR_ID_AMD,
  3610. AMD_762,
  3611. "AMD",
  3612. "AMD 760MP",
  3613. amd_irongate_setup },
  3614. { 0,
  3615. PCI_VENDOR_ID_AMD,
  3616. AMD_GENERIC,
  3617. "AMD",
  3618. "Generic",
  3619. amd_irongate_setup },
  3620. #endif /* CONFIG_AGP_AMD */
  3622. #ifdef CONFIG_AGP_INTEL
  3623. { PCI_DEVICE_ID_INTEL_82443LX_0,
  3624. PCI_VENDOR_ID_INTEL,
  3625. INTEL_LX,
  3626. "Intel",
  3627. "440LX",
  3628. intel_generic_setup },
  3629. { PCI_DEVICE_ID_INTEL_82443BX_0,
  3630. PCI_VENDOR_ID_INTEL,
  3631. INTEL_BX,
  3632. "Intel",
  3633. "440BX",
  3634. intel_generic_setup },
  3635. { PCI_DEVICE_ID_INTEL_82443GX_0,
  3636. PCI_VENDOR_ID_INTEL,
  3637. INTEL_GX,
  3638. "Intel",
  3639. "440GX",
  3640. intel_generic_setup },
  3641. { PCI_DEVICE_ID_INTEL_815_0,
  3642. PCI_VENDOR_ID_INTEL,
  3643. INTEL_I815,
  3644. "Intel",
  3645. "i815",
  3646. intel_generic_setup },
  3647. { PCI_DEVICE_ID_INTEL_820_0,
  3648. PCI_VENDOR_ID_INTEL,
  3649. INTEL_I820,
  3650. "Intel",
  3651. "i820",
  3652. intel_820_setup },
  3653.         { PCI_DEVICE_ID_INTEL_820_UP_0,
  3654.                 PCI_VENDOR_ID_INTEL,
  3655.                 INTEL_I820,
  3656.                 "Intel",
  3657.                  "i820",
  3658.                  intel_820_setup },
  3659. { PCI_DEVICE_ID_INTEL_830_M_0,
  3660. PCI_VENDOR_ID_INTEL,
  3661. INTEL_I830_M,
  3662. "Intel",
  3663. "i830M",
  3664. intel_830mp_setup },
  3665. { PCI_DEVICE_ID_INTEL_840_0,
  3666. PCI_VENDOR_ID_INTEL,
  3667. INTEL_I840,
  3668. "Intel",
  3669. "i840",
  3670. intel_840_setup },
  3671. { PCI_DEVICE_ID_INTEL_845_0,
  3672. PCI_VENDOR_ID_INTEL,
  3673. INTEL_I845,
  3674. "Intel",
  3675. "i845",
  3676. intel_845_setup },
  3677. { PCI_DEVICE_ID_INTEL_850_0,
  3678.         PCI_VENDOR_ID_INTEL,
  3679.         INTEL_I850,
  3680.         "Intel",
  3681.         "i850",
  3682.         intel_850_setup },
  3683. { PCI_DEVICE_ID_INTEL_860_0,
  3684. PCI_VENDOR_ID_INTEL,
  3685. INTEL_I860,
  3686. "Intel",
  3687. "i860",
  3688. intel_860_setup },
  3689. { 0,
  3690. PCI_VENDOR_ID_INTEL,
  3691. INTEL_GENERIC,
  3692. "Intel",
  3693. "Generic",
  3694. intel_generic_setup },
  3696. #endif /* CONFIG_AGP_INTEL */
  3698. #ifdef CONFIG_AGP_SIS
  3699. { PCI_DEVICE_ID_SI_740,
  3700. PCI_VENDOR_ID_SI,
  3701. SIS_GENERIC,
  3702. "SiS",
  3703. "740",
  3704. sis_generic_setup },
  3705. { PCI_DEVICE_ID_SI_650,
  3706. PCI_VENDOR_ID_SI,
  3707. SIS_GENERIC,
  3708. "SiS",
  3709. "650",
  3710. sis_generic_setup },
  3711. { PCI_DEVICE_ID_SI_645,
  3712. PCI_VENDOR_ID_SI,
  3713. SIS_GENERIC,
  3714. "SiS",
  3715. "645",
  3716. sis_generic_setup },
  3717. { PCI_DEVICE_ID_SI_735,
  3718. PCI_VENDOR_ID_SI,
  3719. SIS_GENERIC,
  3720. "SiS",
  3721. "735",
  3722. sis_generic_setup },
  3723. { PCI_DEVICE_ID_SI_730,
  3724. PCI_VENDOR_ID_SI,
  3725. SIS_GENERIC,
  3726. "SiS",
  3727. "730",
  3728. sis_generic_setup },
  3729. { PCI_DEVICE_ID_SI_630,
  3730. PCI_VENDOR_ID_SI,
  3731. SIS_GENERIC,
  3732. "SiS",
  3733. "630",
  3734. sis_generic_setup },
  3735. { PCI_DEVICE_ID_SI_540,
  3736. PCI_VENDOR_ID_SI,
  3737. SIS_GENERIC,
  3738. "SiS",
  3739. "540",
  3740. sis_generic_setup },
  3741. { PCI_DEVICE_ID_SI_620,
  3742. PCI_VENDOR_ID_SI,
  3743. SIS_GENERIC,
  3744. "SiS",
  3745. "620",
  3746. sis_generic_setup },
  3747. { PCI_DEVICE_ID_SI_530,
  3748. PCI_VENDOR_ID_SI,
  3749. SIS_GENERIC,
  3750. "SiS",
  3751. "530",
  3752. sis_generic_setup },
  3753.         { PCI_DEVICE_ID_SI_550,
  3754. PCI_VENDOR_ID_SI,
  3755. SIS_GENERIC,
  3756. "SiS",
  3757.                 "550",
  3758. sis_generic_setup },
  3759. { 0,
  3760. PCI_VENDOR_ID_SI,
  3761. SIS_GENERIC,
  3762. "SiS",
  3763. "Generic",
  3764. sis_generic_setup },
  3765. #endif /* CONFIG_AGP_SIS */
  3767. #ifdef CONFIG_AGP_VIA
  3768. { PCI_DEVICE_ID_VIA_8501_0,
  3769. PCI_VENDOR_ID_VIA,
  3770. VIA_MVP4,
  3771. "Via",
  3772. "MVP4",
  3773. via_generic_setup },
  3774. { PCI_DEVICE_ID_VIA_82C597_0,
  3775. PCI_VENDOR_ID_VIA,
  3776. VIA_VP3,
  3777. "Via",
  3778. "VP3",
  3779. via_generic_setup },
  3780. { PCI_DEVICE_ID_VIA_82C598_0,
  3781. PCI_VENDOR_ID_VIA,
  3782. VIA_MVP3,
  3783. "Via",
  3784. "MVP3",
  3785. via_generic_setup },
  3786. { PCI_DEVICE_ID_VIA_82C691_0,
  3787. PCI_VENDOR_ID_VIA,
  3788. VIA_APOLLO_PRO,
  3789. "Via",
  3790. "Apollo Pro",
  3791. via_generic_setup },
  3792. { PCI_DEVICE_ID_VIA_8371_0,
  3793. PCI_VENDOR_ID_VIA,
  3794. VIA_APOLLO_KX133,
  3795. "Via",
  3796. "Apollo Pro KX133",
  3797. via_generic_setup },
  3798. { PCI_DEVICE_ID_VIA_8363_0,
  3799. PCI_VENDOR_ID_VIA,
  3800. VIA_APOLLO_KT133,
  3801. "Via",
  3802. "Apollo Pro KT133",
  3803. via_generic_setup },
  3804. { PCI_DEVICE_ID_VIA_8367_0,
  3805. PCI_VENDOR_ID_VIA,
  3806. VIA_APOLLO_KT133,
  3807. "Via",
  3808. "Apollo Pro KT266",
  3809. via_generic_setup },
  3810. { 0,
  3811. PCI_VENDOR_ID_VIA,
  3812. VIA_GENERIC,
  3813. "Via",
  3814. "Generic",
  3815. via_generic_setup },
  3816. #endif /* CONFIG_AGP_VIA */
  3818. { 0, }, /* dummy final entry, always present */
  3819. };
  3822. /* scan table above for supported devices */
  3823. static int __init agp_lookup_host_bridge (struct pci_dev *pdev)
  3824. {
  3825. int i;
  3827. for (i = 0; i < ARRAY_SIZE (agp_bridge_info); i++)
  3828. if (pdev->vendor == agp_bridge_info[i].vendor_id)
  3829. break;
  3831. if (i >= ARRAY_SIZE (agp_bridge_info)) {
  3832. printk (KERN_DEBUG PFX "unsupported bridgen");
  3833. return -ENODEV;
  3834. }
  3836. while ((i < ARRAY_SIZE (agp_bridge_info)) &&
  3837.        (agp_bridge_info[i].vendor_id == pdev->vendor)) {
  3838. if (pdev->device == agp_bridge_info[i].device_id) {
  3839. #ifdef CONFIG_AGP_ALI
  3840. if (pdev->device == PCI_DEVICE_ID_AL_M1621_0) {
  3841. u8 hidden_1621_id;
  3843. pci_read_config_byte(pdev, 0xFB, &hidden_1621_id);
  3844. switch (hidden_1621_id) {
  3845. case 0x31:
  3846. agp_bridge_info[i].chipset_name="M1631";
  3847. break;
  3848. case 0x32:
  3849. agp_bridge_info[i].chipset_name="M1632";
  3850. break;
  3851. case 0x41:
  3852. agp_bridge_info[i].chipset_name="M1641";
  3853. break;
  3854. case 0x43:
  3855. break;
  3856. case 0x47:
  3857. agp_bridge_info[i].chipset_name="M1647";
  3858. break;
  3859. case 0x51:
  3860. agp_bridge_info[i].chipset_name="M1651";
  3861. break;
  3862. default:
  3863. break;
  3864. }
  3865. }
  3866. #endif
  3868. printk (KERN_INFO PFX "Detected %s %s chipsetn",
  3869. agp_bridge_info[i].vendor_name,
  3870. agp_bridge_info[i].chipset_name);
  3871. agp_bridge.type = agp_bridge_info[i].chipset;
  3872. return agp_bridge_info[i].chipset_setup (pdev);
  3873. }
  3875. i++;
  3876. }
  3878. i--; /* point to vendor generic entry (device_id == 0) */
  3880. /* try init anyway, if user requests it AND
  3881.  * there is a 'generic' bridge entry for this vendor */
  3882. if (agp_try_unsupported && agp_bridge_info[i].device_id == 0) {
  3883. printk(KERN_WARNING PFX "Trying generic %s routines"
  3884.        " for device id: %04xn",
  3885.        agp_bridge_info[i].vendor_name, pdev->device);
  3886. agp_bridge.type = agp_bridge_info[i].chipset;
  3887. return agp_bridge_info[i].chipset_setup (pdev);
  3888. }
  3890. printk(KERN_ERR PFX "Unsupported %s chipset (device id: %04x),"
  3891.        " you might want to try agp_try_unsupported=1.n",
  3892.        agp_bridge_info[i].vendor_name, pdev->device);
  3893. return -ENODEV;
  3894. }
  3897. /* Supported Device Scanning routine */
  3899. static int __init agp_find_supported_device(void)
  3900. {
  3901. struct pci_dev *dev = NULL;
  3902. u8 cap_ptr = 0x00;
  3903. u32 cap_id, scratch;
  3905. if ((dev = pci_find_class(PCI_CLASS_BRIDGE_HOST << 8, NULL)) == NULL)
  3906. return -ENODEV;
  3908. agp_bridge.dev = dev;
  3910. /* Need to test for I810 here */
  3911. #ifdef CONFIG_AGP_I810
  3912. if (dev->vendor == PCI_VENDOR_ID_INTEL) {
  3913. struct pci_dev *i810_dev;
  3915. switch (dev->device) {
  3916. case PCI_DEVICE_ID_INTEL_810_0:
  3917. i810_dev = pci_find_device(PCI_VENDOR_ID_INTEL,
  3918.        PCI_DEVICE_ID_INTEL_810_1,
  3919.    NULL);
  3920. if (i810_dev == NULL) {
  3921. printk(KERN_ERR PFX "Detected an Intel i810,"
  3922.        " but could not find the secondary"
  3923.        " device.n");
  3924. return -ENODEV;
  3925. }
  3926. printk(KERN_INFO PFX "Detected an Intel "
  3927.        "i810 Chipset.n");
  3928. agp_bridge.type = INTEL_I810;
  3929. return intel_i810_setup (i810_dev);
  3931. case PCI_DEVICE_ID_INTEL_810_DC100_0:
  3932. i810_dev = pci_find_device(PCI_VENDOR_ID_INTEL,
  3933.  PCI_DEVICE_ID_INTEL_810_DC100_1,
  3934.    NULL);
  3935. if (i810_dev == NULL) {
  3936. printk(KERN_ERR PFX "Detected an Intel i810 "
  3937.        "DC100, but could not find the "
  3938.        "secondary device.n");
  3939. return -ENODEV;
  3940. }
  3941. printk(KERN_INFO PFX "Detected an Intel i810 "
  3942.        "DC100 Chipset.n");
  3943. agp_bridge.type = INTEL_I810;
  3944. return intel_i810_setup(i810_dev);
  3946. case PCI_DEVICE_ID_INTEL_810_E_0:
  3947. i810_dev = pci_find_device(PCI_VENDOR_ID_INTEL,
  3948.      PCI_DEVICE_ID_INTEL_810_E_1,
  3949.    NULL);
  3950. if (i810_dev == NULL) {
  3951. printk(KERN_ERR PFX "Detected an Intel i810 E"
  3952.     ", but could not find the secondary "
  3953.        "device.n");
  3954. return -ENODEV;
  3955. }
  3956. printk(KERN_INFO PFX "Detected an Intel i810 E "
  3957.        "Chipset.n");
  3958. agp_bridge.type = INTEL_I810;
  3959. return intel_i810_setup(i810_dev);
  3961.  case PCI_DEVICE_ID_INTEL_815_0:
  3962.    /* The i815 can operate either as an i810 style
  3963.     * integrated device, or as an AGP4X motherboard.
  3964.     *
  3965.     * This only addresses the first mode:
  3966.     */
  3967. i810_dev = pci_find_device(PCI_VENDOR_ID_INTEL,
  3968.    PCI_DEVICE_ID_INTEL_815_1,
  3969.    NULL);
  3970. if (i810_dev == NULL) {
  3971. printk(KERN_ERR PFX "agpgart: Detected an "
  3972.        "Intel i815, but could not find the"
  3973.        " secondary device. Assuming a "
  3974.        "non-integrated video card.n");
  3975. break;
  3976. }
  3977. printk(KERN_INFO PFX "agpgart: Detected an Intel i815 "
  3978.        "Chipset.n");
  3979. agp_bridge.type = INTEL_I810;
  3980. return intel_i810_setup(i810_dev);
  3982. case PCI_DEVICE_ID_INTEL_830_M_0:
  3983. i810_dev = pci_find_device(PCI_VENDOR_ID_INTEL,
  3984. PCI_DEVICE_ID_INTEL_830_M_1, NULL);
  3985. if(i810_dev && PCI_FUNC(i810_dev->devfn) != 0) {
  3986. i810_dev = pci_find_device(PCI_VENDOR_ID_INTEL,
  3987. PCI_DEVICE_ID_INTEL_830_M_1, i810_dev);
  3988. }
  3990. if (i810_dev == NULL) {
  3991.                                 /* 
  3992.                                  * We probably have a I830MP chipset
  3993.                                  * with an external graphics
  3994.                                  * card. It will be initialized later 
  3995.                                  */
  3996. agp_bridge.type = INTEL_I830_M;
  3997. break;
  3998. }
  3999. printk(KERN_INFO PFX "Detected an Intel "
  4000.    "830M Chipset.n");
  4001. agp_bridge.type = INTEL_I810;
  4002. return intel_i830_setup(i810_dev);
  4003. default:
  4004. break;
  4005. }
  4006. }
  4007. #endif /* CONFIG_AGP_I810 */
  4009. #ifdef CONFIG_AGP_SWORKS
  4010. /* Everything is on func 1 here so we are hardcoding function one */
  4011. if (dev->vendor == PCI_VENDOR_ID_SERVERWORKS) {
  4012. struct pci_dev *bridge_dev;
  4014. bridge_dev = pci_find_slot ((unsigned int)dev->bus->number, 
  4015.     PCI_DEVFN(0, 1));
  4016. if(bridge_dev == NULL) {
  4017. printk(KERN_INFO PFX "agpgart: Detected a Serverworks "
  4018.        "Chipset, but could not find the secondary "
  4019.        "device.n");
  4020. return -ENODEV;
  4021. }
  4023. switch (dev->device) {
  4024. case PCI_DEVICE_ID_SERVERWORKS_HE:
  4025. agp_bridge.type = SVWRKS_HE;
  4026. return serverworks_setup(bridge_dev);
  4028. case PCI_DEVICE_ID_SERVERWORKS_LE:
  4029. case 0x0007:
  4030. agp_bridge.type = SVWRKS_LE;
  4031. return serverworks_setup(bridge_dev);
  4033. default:
  4034. if(agp_try_unsupported) {
  4035. agp_bridge.type = SVWRKS_GENERIC;
  4036. return serverworks_setup(bridge_dev);
  4037. }
  4038. break;
  4039. }
  4040. }
  4042. #endif /* CONFIG_AGP_SWORKS */
  4044. /* find capndx */
  4045. pci_read_config_dword(dev, 0x04, &scratch);
  4046. if (!(scratch & 0x00100000))
  4047. return -ENODEV;
  4049. pci_read_config_byte(dev, 0x34, &cap_ptr);
  4050. if (cap_ptr != 0x00) {
  4051. do {
  4052. pci_read_config_dword(dev, cap_ptr, &cap_id);
  4054. if ((cap_id & 0xff) != 0x02)
  4055. cap_ptr = (cap_id >> 8) & 0xff;
  4056. }
  4057. while (((cap_id & 0xff) != 0x02) && (cap_ptr != 0x00));
  4058. }
  4059. if (cap_ptr == 0x00)
  4060. return -ENODEV;
  4061. agp_bridge.capndx = cap_ptr;
  4063. /* Fill in the mode register */
  4064. pci_read_config_dword(agp_bridge.dev,
  4065.       agp_bridge.capndx + 4,
  4066.       &agp_bridge.mode);
  4068. /* probe for known chipsets */
  4069. return agp_lookup_host_bridge (dev);
  4070. }
  4072. struct agp_max_table {
  4073. int mem;
  4074. int agp;
  4075. };
  4077. static struct agp_max_table maxes_table[9] __initdata =
  4078. {
  4079. {0, 0},
  4080. {32, 4},
  4081. {64, 28},
  4082. {128, 96},
  4083. {256, 204},
  4084. {512, 440},
  4085. {1024, 942},
  4086. {2048, 1920},
  4087. {4096, 3932}
  4088. };
  4090. static int __init agp_find_max (void)
  4091. {
  4092. long memory, index, result;
  4094. memory = virt_to_phys(high_memory) >> 20;
  4095. index = 1;
  4097. while ((memory > maxes_table[index].mem) &&
  4098.        (index < 8)) {
  4099. index++;
  4100. }
  4102. result = maxes_table[index - 1].agp +
  4103.    ( (memory - maxes_table[index - 1].mem)  *
  4104.      (maxes_table[index].agp - maxes_table[index - 1].agp)) /
  4105.    (maxes_table[index].mem - maxes_table[index - 1].mem);
  4107. printk(KERN_INFO PFX "Maximum main memory to use "
  4108.        "for agp memory: %ldMn", result);
  4109. result = result << (20 - PAGE_SHIFT);
  4110.         return result;
  4111. }
  4113. #define AGPGART_VERSION_MAJOR 0
  4114. #define AGPGART_VERSION_MINOR 99
  4116. static agp_version agp_current_version =
  4117. {
  4118. AGPGART_VERSION_MAJOR,
  4119. AGPGART_VERSION_MINOR
  4120. };
  4122. static int __init agp_backend_initialize(void)
  4123. {
  4124. int size_value, rc, got_gatt=0, got_keylist=0;
  4126. memset(&agp_bridge, 0, sizeof(struct agp_bridge_data));
  4127. agp_bridge.type = NOT_SUPPORTED;
  4128. agp_bridge.max_memory_agp = agp_find_max();
  4129. agp_bridge.version = &agp_current_version;
  4131. rc = agp_find_supported_device();
  4132. if (rc) {
  4133. /* not KERN_ERR because error msg should have already printed */
  4134. printk(KERN_DEBUG PFX "no supported devices found.n");
  4135. return rc;
  4136. }
  4138. if (agp_bridge.needs_scratch_page == TRUE) {
  4139. agp_bridge.scratch_page = agp_bridge.agp_alloc_page();
  4141. if (agp_bridge.scratch_page == 0) {
  4142. printk(KERN_ERR PFX "unable to get memory for "
  4143.        "scratch page.n");
  4144. return -ENOMEM;
  4145. }
  4146. agp_bridge.scratch_page =
  4147.     virt_to_phys((void *) agp_bridge.scratch_page);
  4148. agp_bridge.scratch_page =
  4149.     agp_bridge.mask_memory(agp_bridge.scratch_page, 0);
  4150. }
  4152. size_value = agp_bridge.fetch_size();
  4154. if (size_value == 0) {
  4155. printk(KERN_ERR PFX "unable to determine aperture size.n");
  4156. rc = -EINVAL;
  4157. goto err_out;
  4158. }
  4159. if (agp_bridge.create_gatt_table()) {
  4160. printk(KERN_ERR PFX "unable to get memory for graphics "
  4161.        "translation table.n");
  4162. rc = -ENOMEM;
  4163. goto err_out;
  4164. }
  4165. got_gatt = 1;
  4167. agp_bridge.key_list = vmalloc(PAGE_SIZE * 4);
  4168. if (agp_bridge.key_list == NULL) {
  4169. printk(KERN_ERR PFX "error allocating memory for key lists.n");
  4170. rc = -ENOMEM;
  4171. goto err_out;
  4172. }
  4173. got_keylist = 1;
  4175. /* FIXME vmalloc'd memory not guaranteed contiguous */
  4176. memset(agp_bridge.key_list, 0, PAGE_SIZE * 4);
  4178. if (agp_bridge.configure()) {
  4179. printk(KERN_ERR PFX "error configuring host chipset.n");
  4180. rc = -EINVAL;
  4181. goto err_out;
  4182. }
  4184. printk(KERN_INFO PFX "AGP aperture is %dM @ 0x%lxn",
  4185.        size_value, agp_bridge.gart_bus_addr);
  4187. return 0;
  4189. err_out:
  4190. if (agp_bridge.needs_scratch_page == TRUE) {
  4191. agp_bridge.scratch_page &= ~(0x00000fff);
  4192. agp_bridge.agp_destroy_page((unsigned long)
  4193.  phys_to_virt(agp_bridge.scratch_page));
  4194. }
  4195. if (got_gatt)
  4196. agp_bridge.free_gatt_table();
  4197. if (got_keylist)
  4198. vfree(agp_bridge.key_list);
  4199. return rc;
  4200. }
  4203. /* cannot be __exit b/c as it could be called from __init code */
  4204. static void agp_backend_cleanup(void)
  4205. {
  4206. agp_bridge.cleanup();
  4207. agp_bridge.free_gatt_table();
  4208. vfree(agp_bridge.key_list);
  4210. if (agp_bridge.needs_scratch_page == TRUE) {
  4211. agp_bridge.scratch_page &= ~(0x00000fff);
  4212. agp_bridge.agp_destroy_page((unsigned long)
  4213.  phys_to_virt(agp_bridge.scratch_page));
  4214. }
  4215. }
  4217. static int agp_power(struct pm_dev *dev, pm_request_t rq, void *data)
  4218. {
  4219. switch(rq)
  4220. {
  4221. case PM_SUSPEND:
  4222. return agp_bridge.suspend();
  4223. case PM_RESUME:
  4224. agp_bridge.resume();
  4225. return 0;
  4226. }
  4227. return 0;
  4228. }
  4230. extern int agp_frontend_initialize(void);
  4231. extern void agp_frontend_cleanup(void);
  4233. static const drm_agp_t drm_agp = {
  4234. &agp_free_memory,
  4235. &agp_allocate_memory,
  4236. &agp_bind_memory,
  4237. &agp_unbind_memory,
  4238. &agp_enable,
  4239. &agp_backend_acquire,
  4240. &agp_backend_release,
  4241. &agp_copy_info
  4242. };
  4244. static int __init agp_init(void)
  4245. {
  4246. int ret_val;
  4248. printk(KERN_INFO "Linux agpgart interface v%d.%d (c) Jeff Hartmannn",
  4249.        AGPGART_VERSION_MAJOR, AGPGART_VERSION_MINOR);
  4251. ret_val = agp_backend_initialize();
  4252. if (ret_val) {
  4253. agp_bridge.type = NOT_SUPPORTED;
  4254. return ret_val;
  4255. }
  4256. ret_val = agp_frontend_initialize();
  4257. if (ret_val) {
  4258. agp_bridge.type = NOT_SUPPORTED;
  4259. agp_backend_cleanup();
  4260. return ret_val;
  4261. }
  4263. inter_module_register("drm_agp", THIS_MODULE, &drm_agp);
  4265. pm_register(PM_PCI_DEV, PM_PCI_ID(agp_bridge.dev), agp_power);
  4266. return 0;
  4267. }
  4269. static void __exit agp_cleanup(void)
  4270. {
  4271. pm_unregister_all(agp_power);
  4272. agp_frontend_cleanup();
  4273. agp_backend_cleanup();
  4274. inter_module_unregister("drm_agp");
  4275. }
  4277. module_init(agp_init);
  4278. module_exit(agp_cleanup);