2 * Nvidia AGPGART routines.
3 * Based upon a 2.4 agpgart diff by the folks from NVIDIA, and hacked up
4 * to work in 2.5 by Dave Jones <davej@codemonkey.org.uk>
7 #include <linux/module.h>
9 #include <linux/init.h>
10 #include <linux/agp_backend.h>
11 #include <linux/gfp.h>
12 #include <linux/page-flags.h>
18 #define NVIDIA_0_APBASE 0x10
19 #define NVIDIA_0_APSIZE 0x80
20 #define NVIDIA_1_WBC 0xf0
21 #define NVIDIA_2_GARTCTRL 0xd0
22 #define NVIDIA_2_APBASE 0xd8
23 #define NVIDIA_2_APLIMIT 0xdc
24 #define NVIDIA_2_ATTBASE(i) (0xe0 + (i) * 4)
25 #define NVIDIA_3_APBASE 0x50
26 #define NVIDIA_3_APLIMIT 0x54
29 static int agp_try_unsupported __initdata
= 0;
31 static struct _nvidia_private
{
32 struct pci_dev
*dev_1
;
33 struct pci_dev
*dev_2
;
34 struct pci_dev
*dev_3
;
35 volatile u32
*aperture
;
36 int num_active_entries
;
42 static int nvidia_fetch_size(void)
46 struct aper_size_info_8
*values
;
48 pci_read_config_byte(agp_bridge
->dev
, NVIDIA_0_APSIZE
, &size_value
);
50 values
= A_SIZE_8(agp_bridge
->driver
->aperture_sizes
);
52 for (i
= 0; i
< agp_bridge
->driver
->num_aperture_sizes
; i
++) {
53 if (size_value
== values
[i
].size_value
) {
54 agp_bridge
->previous_size
=
55 agp_bridge
->current_size
= (void *) (values
+ i
);
56 agp_bridge
->aperture_size_idx
= i
;
57 return values
[i
].size
;
65 static int nvidia_configure(void)
69 struct aper_size_info_8
*current_size
;
72 current_size
= A_SIZE_8(agp_bridge
->current_size
);
75 pci_write_config_byte(agp_bridge
->dev
, NVIDIA_0_APSIZE
,
76 current_size
->size_value
);
78 /* address to map to */
79 pci_read_config_dword(agp_bridge
->dev
, NVIDIA_0_APBASE
, &apbase
);
80 apbase
&= PCI_BASE_ADDRESS_MEM_MASK
;
81 agp_bridge
->gart_bus_addr
= apbase
;
82 aplimit
= apbase
+ (current_size
->size
* 1024 * 1024) - 1;
83 pci_write_config_dword(nvidia_private
.dev_2
, NVIDIA_2_APBASE
, apbase
);
84 pci_write_config_dword(nvidia_private
.dev_2
, NVIDIA_2_APLIMIT
, aplimit
);
85 pci_write_config_dword(nvidia_private
.dev_3
, NVIDIA_3_APBASE
, apbase
);
86 pci_write_config_dword(nvidia_private
.dev_3
, NVIDIA_3_APLIMIT
, aplimit
);
88 /* directory size is 64k */
89 num_dirs
= current_size
->size
/ 64;
90 nvidia_private
.num_active_entries
= current_size
->num_entries
;
91 nvidia_private
.pg_offset
= 0;
94 nvidia_private
.num_active_entries
/= (64 / current_size
->size
);
95 nvidia_private
.pg_offset
= (apbase
& (64 * 1024 * 1024 - 1) &
96 ~(current_size
->size
* 1024 * 1024 - 1)) / PAGE_SIZE
;
100 for(i
= 0; i
< 8; i
++) {
101 pci_write_config_dword(nvidia_private
.dev_2
, NVIDIA_2_ATTBASE(i
),
102 (agp_bridge
->gatt_bus_addr
+ (i
% num_dirs
) * 64 * 1024) | 1);
106 pci_read_config_dword(nvidia_private
.dev_2
, NVIDIA_2_GARTCTRL
, &temp
);
107 pci_write_config_dword(nvidia_private
.dev_2
, NVIDIA_2_GARTCTRL
, temp
| 0x11);
110 pci_read_config_dword(agp_bridge
->dev
, NVIDIA_0_APSIZE
, &temp
);
111 pci_write_config_dword(agp_bridge
->dev
, NVIDIA_0_APSIZE
, temp
| 0x100);
114 nvidia_private
.aperture
=
115 (volatile u32
*) ioremap(apbase
, 33 * PAGE_SIZE
);
120 static void nvidia_cleanup(void)
122 struct aper_size_info_8
*previous_size
;
126 pci_read_config_dword(agp_bridge
->dev
, NVIDIA_0_APSIZE
, &temp
);
127 pci_write_config_dword(agp_bridge
->dev
, NVIDIA_0_APSIZE
, temp
& ~(0x100));
130 pci_read_config_dword(nvidia_private
.dev_2
, NVIDIA_2_GARTCTRL
, &temp
);
131 pci_write_config_dword(nvidia_private
.dev_2
, NVIDIA_2_GARTCTRL
, temp
& ~(0x11));
134 iounmap((void *) nvidia_private
.aperture
);
136 /* restore previous aperture size */
137 previous_size
= A_SIZE_8(agp_bridge
->previous_size
);
138 pci_write_config_byte(agp_bridge
->dev
, NVIDIA_0_APSIZE
,
139 previous_size
->size_value
);
144 * Note we can't use the generic routines, even though they are 99% the same.
145 * Aperture sizes <64M still requires a full 64k GART directory, but
146 * only use the portion of the TLB entries that correspond to the apertures
147 * alignment inside the surrounding 64M block.
149 extern int agp_memory_reserved
;
151 static int nvidia_insert_memory(struct agp_memory
*mem
, off_t pg_start
, int type
)
155 if ((type
!= 0) || (mem
->type
!= 0))
158 if ((pg_start
+ mem
->page_count
) >
159 (nvidia_private
.num_active_entries
- agp_memory_reserved
/PAGE_SIZE
))
162 for(j
= pg_start
; j
< (pg_start
+ mem
->page_count
); j
++) {
163 if (!PGE_EMPTY(agp_bridge
, agp_bridge
->gatt_table
[nvidia_private
.pg_offset
+ j
]))
167 if (mem
->is_flushed
== FALSE
) {
168 global_cache_flush();
169 mem
->is_flushed
= TRUE
;
171 for (i
= 0, j
= pg_start
; i
< mem
->page_count
; i
++, j
++)
172 agp_bridge
->gatt_table
[nvidia_private
.pg_offset
+ j
] =
173 agp_bridge
->driver
->mask_memory(mem
->memory
[i
], mem
->type
);
175 agp_bridge
->driver
->tlb_flush(mem
);
180 static int nvidia_remove_memory(struct agp_memory
*mem
, off_t pg_start
, int type
)
184 if ((type
!= 0) || (mem
->type
!= 0))
187 for (i
= pg_start
; i
< (mem
->page_count
+ pg_start
); i
++) {
188 agp_bridge
->gatt_table
[nvidia_private
.pg_offset
+ i
] =
189 (unsigned long) agp_bridge
->scratch_page
;
192 agp_bridge
->driver
->tlb_flush(mem
);
197 static void nvidia_tlbflush(struct agp_memory
*mem
)
204 if (nvidia_private
.wbc_mask
) {
205 pci_read_config_dword(nvidia_private
.dev_1
, NVIDIA_1_WBC
, &wbc_reg
);
206 wbc_reg
|= nvidia_private
.wbc_mask
;
207 pci_write_config_dword(nvidia_private
.dev_1
, NVIDIA_1_WBC
, wbc_reg
);
209 end
= jiffies
+ 3*HZ
;
211 pci_read_config_dword(nvidia_private
.dev_1
,
212 NVIDIA_1_WBC
, &wbc_reg
);
213 if ((signed)(end
- jiffies
) <= 0) {
215 "TLB flush took more than 3 seconds.\n");
217 } while (wbc_reg
& nvidia_private
.wbc_mask
);
220 /* flush TLB entries */
221 for(i
= 0; i
< 32 + 1; i
++)
222 temp
= nvidia_private
.aperture
[i
* PAGE_SIZE
/ sizeof(u32
)];
223 for(i
= 0; i
< 32 + 1; i
++)
224 temp
= nvidia_private
.aperture
[i
* PAGE_SIZE
/ sizeof(u32
)];
228 static struct aper_size_info_8 nvidia_generic_sizes
[5] =
234 /* The 32M mode still requires a 64k gatt */
239 static struct gatt_mask nvidia_generic_masks
[] =
241 { .mask
= 1, .type
= 0}
245 struct agp_bridge_driver nvidia_driver
= {
246 .owner
= THIS_MODULE
,
247 .aperture_sizes
= nvidia_generic_sizes
,
248 .size_type
= U8_APER_SIZE
,
249 .num_aperture_sizes
= 5,
250 .configure
= nvidia_configure
,
251 .fetch_size
= nvidia_fetch_size
,
252 .cleanup
= nvidia_cleanup
,
253 .tlb_flush
= nvidia_tlbflush
,
254 .mask_memory
= agp_generic_mask_memory
,
255 .masks
= nvidia_generic_masks
,
256 .agp_enable
= agp_generic_enable
,
257 .cache_flush
= global_cache_flush
,
258 .create_gatt_table
= agp_generic_create_gatt_table
,
259 .free_gatt_table
= agp_generic_free_gatt_table
,
260 .insert_memory
= nvidia_insert_memory
,
261 .remove_memory
= nvidia_remove_memory
,
262 .alloc_by_type
= agp_generic_alloc_by_type
,
263 .free_by_type
= agp_generic_free_by_type
,
264 .agp_alloc_page
= agp_generic_alloc_page
,
265 .agp_destroy_page
= agp_generic_destroy_page
,
268 static int __init
agp_nvidia_probe(struct pci_dev
*pdev
,
269 const struct pci_device_id
*ent
)
271 struct agp_bridge_data
*bridge
;
274 nvidia_private
.dev_1
=
275 pci_find_slot((unsigned int)pdev
->bus
->number
, PCI_DEVFN(0, 1));
276 nvidia_private
.dev_2
=
277 pci_find_slot((unsigned int)pdev
->bus
->number
, PCI_DEVFN(0, 2));
278 nvidia_private
.dev_3
=
279 pci_find_slot((unsigned int)pdev
->bus
->number
, PCI_DEVFN(30, 0));
281 if (!nvidia_private
.dev_1
|| !nvidia_private
.dev_2
|| !nvidia_private
.dev_3
) {
282 printk(KERN_INFO PFX
"agpgart: Detected an NVIDIA "
283 "nForce/nForce2 chipset, but could not find "
284 "the secondary devices.\n");
288 cap_ptr
= pci_find_capability(pdev
, PCI_CAP_ID_AGP
);
292 switch (pdev
->device
) {
293 case PCI_DEVICE_ID_NVIDIA_NFORCE
:
294 printk(KERN_INFO PFX
"Detected NVIDIA nForce chipset\n");
295 nvidia_private
.wbc_mask
= 0x00010000;
297 case PCI_DEVICE_ID_NVIDIA_NFORCE2
:
298 printk(KERN_INFO PFX
"Detected NVIDIA nForce2 chipset\n");
299 nvidia_private
.wbc_mask
= 0x80000000;
302 if (!agp_try_unsupported
) {
304 "Unsupported NVIDIA chipset (device id: %04x),"
305 " you might want to try agp_try_unsupported=1.\n",
309 printk(KERN_WARNING PFX
310 "Trying generic NVIDIA routines for device id: %04x\n",
315 bridge
= agp_alloc_bridge();
319 bridge
->driver
= &nvidia_driver
;
320 bridge
->dev_private_data
= &nvidia_private
,
322 bridge
->capndx
= cap_ptr
;
324 /* Fill in the mode register */
325 pci_read_config_dword(pdev
,
326 bridge
->capndx
+PCI_AGP_STATUS
,
329 pci_set_drvdata(pdev
, bridge
);
330 return agp_add_bridge(bridge
);
333 static void __devexit
agp_nvidia_remove(struct pci_dev
*pdev
)
335 struct agp_bridge_data
*bridge
= pci_get_drvdata(pdev
);
337 agp_remove_bridge(bridge
);
338 agp_put_bridge(bridge
);
341 static struct pci_device_id agp_nvidia_pci_table
[] __initdata
= {
343 .class = (PCI_CLASS_BRIDGE_HOST
<< 8),
345 .vendor
= PCI_VENDOR_ID_NVIDIA
,
346 .device
= PCI_ANY_ID
,
347 .subvendor
= PCI_ANY_ID
,
348 .subdevice
= PCI_ANY_ID
,
353 MODULE_DEVICE_TABLE(pci
, agp_nvidia_pci_table
);
355 static struct pci_driver agp_nvidia_pci_driver
= {
356 .name
= "agpgart-nvidia",
357 .id_table
= agp_nvidia_pci_table
,
358 .probe
= agp_nvidia_probe
,
359 .remove
= agp_nvidia_remove
,
362 static int __init
agp_nvidia_init(void)
364 return pci_module_init(&agp_nvidia_pci_driver
);
367 static void __exit
agp_nvidia_cleanup(void)
369 pci_unregister_driver(&agp_nvidia_pci_driver
);
372 module_init(agp_nvidia_init
);
373 module_exit(agp_nvidia_cleanup
);
375 MODULE_PARM(agp_try_unsupported
, "1i");
376 MODULE_LICENSE("GPL and additional rights");
377 MODULE_AUTHOR("NVIDIA Corporation");