2 * Serverworks AGPGART routines.
5 #include <linux/module.h>
7 #include <linux/init.h>
8 #include <linux/agp_backend.h>
11 static int agp_try_unsupported __initdata
= 0;
13 struct serverworks_page_map
{
15 unsigned long *remapped
;
18 static struct _serverworks_private
{
19 struct pci_dev
*svrwrks_dev
; /* device one */
20 volatile u8
*registers
;
21 struct serverworks_page_map
**gatt_pages
;
23 struct serverworks_page_map scratch_dir
;
27 } serverworks_private
;
29 static int serverworks_create_page_map(struct serverworks_page_map
*page_map
)
33 page_map
->real
= (unsigned long *) __get_free_page(GFP_KERNEL
);
34 if (page_map
->real
== NULL
) {
37 SetPageReserved(virt_to_page(page_map
->real
));
39 page_map
->remapped
= ioremap_nocache(virt_to_phys(page_map
->real
),
41 if (page_map
->remapped
== NULL
) {
42 ClearPageReserved(virt_to_page(page_map
->real
));
43 free_page((unsigned long) page_map
->real
);
44 page_map
->real
= NULL
;
49 for(i
= 0; i
< PAGE_SIZE
/ sizeof(unsigned long); i
++) {
50 page_map
->remapped
[i
] = agp_bridge
->scratch_page
;
56 static void serverworks_free_page_map(struct serverworks_page_map
*page_map
)
58 iounmap(page_map
->remapped
);
59 ClearPageReserved(virt_to_page(page_map
->real
));
60 free_page((unsigned long) page_map
->real
);
63 static void serverworks_free_gatt_pages(void)
66 struct serverworks_page_map
**tables
;
67 struct serverworks_page_map
*entry
;
69 tables
= serverworks_private
.gatt_pages
;
70 for(i
= 0; i
< serverworks_private
.num_tables
; i
++) {
73 if (entry
->real
!= NULL
) {
74 serverworks_free_page_map(entry
);
82 static int serverworks_create_gatt_pages(int nr_tables
)
84 struct serverworks_page_map
**tables
;
85 struct serverworks_page_map
*entry
;
89 tables
= kmalloc((nr_tables
+ 1) * sizeof(struct serverworks_page_map
*),
94 memset(tables
, 0, sizeof(struct serverworks_page_map
*) * (nr_tables
+ 1));
95 for (i
= 0; i
< nr_tables
; i
++) {
96 entry
= kmalloc(sizeof(struct serverworks_page_map
), GFP_KERNEL
);
101 memset(entry
, 0, sizeof(struct serverworks_page_map
));
103 retval
= serverworks_create_page_map(entry
);
104 if (retval
!= 0) break;
106 serverworks_private
.num_tables
= nr_tables
;
107 serverworks_private
.gatt_pages
= tables
;
109 if (retval
!= 0) serverworks_free_gatt_pages();
114 #define SVRWRKS_GET_GATT(addr) (serverworks_private.gatt_pages[\
115 GET_PAGE_DIR_IDX(addr)]->remapped)
117 #ifndef GET_PAGE_DIR_OFF
118 #define GET_PAGE_DIR_OFF(addr) (addr >> 22)
121 #ifndef GET_PAGE_DIR_IDX
122 #define GET_PAGE_DIR_IDX(addr) (GET_PAGE_DIR_OFF(addr) - \
123 GET_PAGE_DIR_OFF(agp_bridge->gart_bus_addr))
127 #define GET_GATT_OFF(addr) ((addr & 0x003ff000) >> 12)
130 static int serverworks_create_gatt_table(void)
132 struct aper_size_info_lvl2
*value
;
133 struct serverworks_page_map page_dir
;
138 value
= A_SIZE_LVL2(agp_bridge
->current_size
);
139 retval
= serverworks_create_page_map(&page_dir
);
143 retval
= serverworks_create_page_map(&serverworks_private
.scratch_dir
);
145 serverworks_free_page_map(&page_dir
);
148 /* Create a fake scratch directory */
149 for(i
= 0; i
< 1024; i
++) {
150 serverworks_private
.scratch_dir
.remapped
[i
] = (unsigned long) agp_bridge
->scratch_page
;
151 page_dir
.remapped
[i
] =
152 virt_to_phys(serverworks_private
.scratch_dir
.real
);
153 page_dir
.remapped
[i
] |= 0x00000001;
156 retval
= serverworks_create_gatt_pages(value
->num_entries
/ 1024);
158 serverworks_free_page_map(&page_dir
);
159 serverworks_free_page_map(&serverworks_private
.scratch_dir
);
163 agp_bridge
->gatt_table_real
= (u32
*)page_dir
.real
;
164 agp_bridge
->gatt_table
= (u32
*)page_dir
.remapped
;
165 agp_bridge
->gatt_bus_addr
= virt_to_phys(page_dir
.real
);
167 /* Get the address for the gart region.
168 * This is a bus address even on the alpha, b/c its
169 * used to program the agp master not the cpu
172 pci_read_config_dword(agp_bridge
->dev
,serverworks_private
.gart_addr_ofs
,&temp
);
173 agp_bridge
->gart_bus_addr
= (temp
& PCI_BASE_ADDRESS_MEM_MASK
);
175 /* Calculate the agp offset */
177 for(i
= 0; i
< value
->num_entries
/ 1024; i
++) {
178 page_dir
.remapped
[i
] =
179 virt_to_phys(serverworks_private
.gatt_pages
[i
]->real
);
180 page_dir
.remapped
[i
] |= 0x00000001;
186 static int serverworks_free_gatt_table(void)
188 struct serverworks_page_map page_dir
;
190 page_dir
.real
= (unsigned long *)agp_bridge
->gatt_table_real
;
191 page_dir
.remapped
= (unsigned long *)agp_bridge
->gatt_table
;
193 serverworks_free_gatt_pages();
194 serverworks_free_page_map(&page_dir
);
195 serverworks_free_page_map(&serverworks_private
.scratch_dir
);
199 static int serverworks_fetch_size(void)
204 struct aper_size_info_lvl2
*values
;
206 values
= A_SIZE_LVL2(agp_bridge
->driver
->aperture_sizes
);
207 pci_read_config_dword(agp_bridge
->dev
,serverworks_private
.gart_addr_ofs
,&temp
);
208 pci_write_config_dword(agp_bridge
->dev
,serverworks_private
.gart_addr_ofs
,
210 pci_read_config_dword(agp_bridge
->dev
,serverworks_private
.gart_addr_ofs
,&temp2
);
211 pci_write_config_dword(agp_bridge
->dev
,serverworks_private
.gart_addr_ofs
,temp
);
212 temp2
&= SVWRKS_SIZE_MASK
;
214 for (i
= 0; i
< agp_bridge
->driver
->num_aperture_sizes
; i
++) {
215 if (temp2
== values
[i
].size_value
) {
216 agp_bridge
->previous_size
=
217 agp_bridge
->current_size
= (void *) (values
+ i
);
219 agp_bridge
->aperture_size_idx
= i
;
220 return values
[i
].size
;
228 * This routine could be implemented by taking the addresses
229 * written to the GATT, and flushing them individually. However
230 * currently it just flushes the whole table. Which is probably
231 * more efficent, since agp_memory blocks can be a large number of
234 static void serverworks_tlbflush(struct agp_memory
*temp
)
238 OUTREG8(serverworks_private
.registers
, SVWRKS_POSTFLUSH
, 0x01);
239 end
= jiffies
+ 3*HZ
;
240 while(INREG8(serverworks_private
.registers
,
241 SVWRKS_POSTFLUSH
) == 0x01) {
242 if((signed)(end
- jiffies
) <= 0) {
243 printk(KERN_ERR PFX
"Posted write buffer flush took more"
247 OUTREG32(serverworks_private
.registers
, SVWRKS_DIRFLUSH
, 0x00000001);
248 end
= jiffies
+ 3*HZ
;
249 while(INREG32(serverworks_private
.registers
,
250 SVWRKS_DIRFLUSH
) == 0x00000001) {
251 if((signed)(end
- jiffies
) <= 0) {
252 printk(KERN_ERR PFX
"TLB flush took more"
258 static int serverworks_configure(void)
260 struct aper_size_info_lvl2
*current_size
;
265 current_size
= A_SIZE_LVL2(agp_bridge
->current_size
);
267 /* Get the memory mapped registers */
268 pci_read_config_dword(agp_bridge
->dev
, serverworks_private
.mm_addr_ofs
, &temp
);
269 temp
= (temp
& PCI_BASE_ADDRESS_MEM_MASK
);
270 serverworks_private
.registers
= (volatile u8
*) ioremap(temp
, 4096);
272 OUTREG8(serverworks_private
.registers
, SVWRKS_GART_CACHE
, 0x0a);
274 OUTREG32(serverworks_private
.registers
, SVWRKS_GATTBASE
,
275 agp_bridge
->gatt_bus_addr
);
277 cap_reg
= INREG16(serverworks_private
.registers
, SVWRKS_COMMAND
);
280 OUTREG16(serverworks_private
.registers
, SVWRKS_COMMAND
, cap_reg
);
282 pci_read_config_byte(serverworks_private
.svrwrks_dev
,
283 SVWRKS_AGP_ENABLE
, &enable_reg
);
284 enable_reg
|= 0x1; /* Agp Enable bit */
285 pci_write_config_byte(serverworks_private
.svrwrks_dev
,
286 SVWRKS_AGP_ENABLE
, enable_reg
);
287 serverworks_tlbflush(NULL
);
289 agp_bridge
->capndx
= pci_find_capability(serverworks_private
.svrwrks_dev
, PCI_CAP_ID_AGP
);
291 /* Fill in the mode register */
292 pci_read_config_dword(serverworks_private
.svrwrks_dev
,
293 agp_bridge
->capndx
+PCI_AGP_STATUS
, &agp_bridge
->mode
);
295 pci_read_config_byte(agp_bridge
->dev
, SVWRKS_CACHING
, &enable_reg
);
297 pci_write_config_byte(agp_bridge
->dev
, SVWRKS_CACHING
, enable_reg
);
299 pci_read_config_byte(agp_bridge
->dev
, SVWRKS_FEATURE
, &enable_reg
);
300 enable_reg
|= (1<<6);
301 pci_write_config_byte(agp_bridge
->dev
,SVWRKS_FEATURE
, enable_reg
);
306 static void serverworks_cleanup(void)
308 iounmap((void *) serverworks_private
.registers
);
311 static int serverworks_insert_memory(struct agp_memory
*mem
,
312 off_t pg_start
, int type
)
314 int i
, j
, num_entries
;
315 unsigned long *cur_gatt
;
318 num_entries
= A_SIZE_LVL2(agp_bridge
->current_size
)->num_entries
;
320 if (type
!= 0 || mem
->type
!= 0) {
323 if ((pg_start
+ mem
->page_count
) > num_entries
) {
328 while (j
< (pg_start
+ mem
->page_count
)) {
329 addr
= (j
* PAGE_SIZE
) + agp_bridge
->gart_bus_addr
;
330 cur_gatt
= SVRWRKS_GET_GATT(addr
);
331 if (!PGE_EMPTY(agp_bridge
, cur_gatt
[GET_GATT_OFF(addr
)])) {
337 if (mem
->is_flushed
== FALSE
) {
338 global_cache_flush();
339 mem
->is_flushed
= TRUE
;
342 for (i
= 0, j
= pg_start
; i
< mem
->page_count
; i
++, j
++) {
343 addr
= (j
* PAGE_SIZE
) + agp_bridge
->gart_bus_addr
;
344 cur_gatt
= SVRWRKS_GET_GATT(addr
);
345 cur_gatt
[GET_GATT_OFF(addr
)] =
346 agp_bridge
->driver
->mask_memory(mem
->memory
[i
], mem
->type
);
348 serverworks_tlbflush(mem
);
352 static int serverworks_remove_memory(struct agp_memory
*mem
, off_t pg_start
,
356 unsigned long *cur_gatt
;
359 if (type
!= 0 || mem
->type
!= 0) {
363 global_cache_flush();
364 serverworks_tlbflush(mem
);
366 for (i
= pg_start
; i
< (mem
->page_count
+ pg_start
); i
++) {
367 addr
= (i
* PAGE_SIZE
) + agp_bridge
->gart_bus_addr
;
368 cur_gatt
= SVRWRKS_GET_GATT(addr
);
369 cur_gatt
[GET_GATT_OFF(addr
)] =
370 (unsigned long) agp_bridge
->scratch_page
;
373 serverworks_tlbflush(mem
);
377 static struct gatt_mask serverworks_masks
[] =
379 {.mask
= 1, .type
= 0}
382 static struct aper_size_info_lvl2 serverworks_sizes
[7] =
384 {2048, 524288, 0x80000000},
385 {1024, 262144, 0xc0000000},
386 {512, 131072, 0xe0000000},
387 {256, 65536, 0xf0000000},
388 {128, 32768, 0xf8000000},
389 {64, 16384, 0xfc000000},
390 {32, 8192, 0xfe000000}
393 static void serverworks_agp_enable(u32 mode
)
397 pci_read_config_dword(serverworks_private
.svrwrks_dev
,
398 agp_bridge
->capndx
+ PCI_AGP_STATUS
,
401 command
= agp_collect_device_status(mode
, command
);
403 command
&= ~0x10; /* disable FW */
408 pci_write_config_dword(serverworks_private
.svrwrks_dev
,
409 agp_bridge
->capndx
+ PCI_AGP_COMMAND
,
412 agp_device_command(command
, 0);
415 struct agp_bridge_driver sworks_driver
= {
416 .owner
= THIS_MODULE
,
417 .aperture_sizes
= serverworks_sizes
,
418 .size_type
= LVL2_APER_SIZE
,
419 .num_aperture_sizes
= 7,
420 .configure
= serverworks_configure
,
421 .fetch_size
= serverworks_fetch_size
,
422 .cleanup
= serverworks_cleanup
,
423 .tlb_flush
= serverworks_tlbflush
,
424 .mask_memory
= agp_generic_mask_memory
,
425 .masks
= serverworks_masks
,
426 .agp_enable
= serverworks_agp_enable
,
427 .cache_flush
= global_cache_flush
,
428 .create_gatt_table
= serverworks_create_gatt_table
,
429 .free_gatt_table
= serverworks_free_gatt_table
,
430 .insert_memory
= serverworks_insert_memory
,
431 .remove_memory
= serverworks_remove_memory
,
432 .alloc_by_type
= agp_generic_alloc_by_type
,
433 .free_by_type
= agp_generic_free_by_type
,
434 .agp_alloc_page
= agp_generic_alloc_page
,
435 .agp_destroy_page
= agp_generic_destroy_page
,
438 static int __init
agp_serverworks_probe(struct pci_dev
*pdev
,
439 const struct pci_device_id
*ent
)
441 struct agp_bridge_data
*bridge
;
442 struct pci_dev
*bridge_dev
;
445 /* Everything is on func 1 here so we are hardcoding function one */
446 bridge_dev
= pci_find_slot((unsigned int)pdev
->bus
->number
,
449 printk(KERN_INFO PFX
"agpgart: Detected a Serverworks "
450 "Chipset, but could not find the secondary device.\n");
454 switch (pdev
->device
) {
455 case PCI_DEVICE_ID_SERVERWORKS_HE
:
456 case PCI_DEVICE_ID_SERVERWORKS_LE
:
460 if (!agp_try_unsupported
)
465 serverworks_private
.svrwrks_dev
= bridge_dev
;
466 serverworks_private
.gart_addr_ofs
= 0x10;
468 pci_read_config_dword(pdev
, SVWRKS_APSIZE
, &temp
);
469 if (temp
& PCI_BASE_ADDRESS_MEM_TYPE_64
) {
470 pci_read_config_dword(pdev
, SVWRKS_APSIZE
+ 4, &temp2
);
472 printk(KERN_INFO PFX
"Detected 64 bit aperture address, "
473 "but top bits are not zero. Disabling agp\n");
476 serverworks_private
.mm_addr_ofs
= 0x18;
478 serverworks_private
.mm_addr_ofs
= 0x14;
480 pci_read_config_dword(pdev
, serverworks_private
.mm_addr_ofs
, &temp
);
481 if (temp
& PCI_BASE_ADDRESS_MEM_TYPE_64
) {
482 pci_read_config_dword(pdev
,
483 serverworks_private
.mm_addr_ofs
+ 4, &temp2
);
485 printk(KERN_INFO PFX
"Detected 64 bit MMIO address, "
486 "but top bits are not zero. Disabling agp\n");
491 bridge
= agp_alloc_bridge();
495 bridge
->driver
= &sworks_driver
;
496 bridge
->dev_private_data
= &serverworks_private
,
499 pci_set_drvdata(pdev
, bridge
);
500 return agp_add_bridge(bridge
);
503 static void __devexit
agp_serverworks_remove(struct pci_dev
*pdev
)
505 struct agp_bridge_data
*bridge
= pci_get_drvdata(pdev
);
507 agp_remove_bridge(bridge
);
508 agp_put_bridge(bridge
);
511 static struct pci_device_id agp_serverworks_pci_table
[] __initdata
= {
513 .class = (PCI_CLASS_BRIDGE_HOST
<< 8),
515 .vendor
= PCI_VENDOR_ID_SERVERWORKS
,
516 .device
= PCI_ANY_ID
,
517 .subvendor
= PCI_ANY_ID
,
518 .subdevice
= PCI_ANY_ID
,
523 MODULE_DEVICE_TABLE(pci
, agp_serverworks_pci_table
);
525 static struct pci_driver agp_serverworks_pci_driver
= {
526 .name
= "agpgart-serverworks",
527 .id_table
= agp_serverworks_pci_table
,
528 .probe
= agp_serverworks_probe
,
529 .remove
= agp_serverworks_remove
,
532 static int __init
agp_serverworks_init(void)
534 return pci_module_init(&agp_serverworks_pci_driver
);
537 static void __exit
agp_serverworks_cleanup(void)
539 pci_unregister_driver(&agp_serverworks_pci_driver
);
542 module_init(agp_serverworks_init
);
543 module_exit(agp_serverworks_cleanup
);
545 MODULE_PARM(agp_try_unsupported
, "1i");
546 MODULE_LICENSE("GPL and additional rights");