2 * Intel AGPGART routines.
5 #include <linux/module.h>
7 #include <linux/init.h>
8 #include <linux/kernel.h>
9 #include <linux/pagemap.h>
10 #include <linux/agp_backend.h>
13 #define PCI_DEVICE_ID_INTEL_82946GZ_HB 0x2970
14 #define PCI_DEVICE_ID_INTEL_82946GZ_IG 0x2972
15 #define PCI_DEVICE_ID_INTEL_82965G_1_HB 0x2980
16 #define PCI_DEVICE_ID_INTEL_82965G_1_IG 0x2982
17 #define PCI_DEVICE_ID_INTEL_82965Q_HB 0x2990
18 #define PCI_DEVICE_ID_INTEL_82965Q_IG 0x2992
19 #define PCI_DEVICE_ID_INTEL_82965G_HB 0x29A0
20 #define PCI_DEVICE_ID_INTEL_82965G_IG 0x29A2
21 #define PCI_DEVICE_ID_INTEL_82965GM_HB 0x2A00
22 #define PCI_DEVICE_ID_INTEL_82965GM_IG 0x2A02
24 #define IS_I965 (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82946GZ_HB || \
25 agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82965G_1_HB || \
26 agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82965Q_HB || \
27 agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82965G_HB || \
28 agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82965GM_HB)
31 extern int agp_memory_reserved
;
34 /* Intel 815 register */
35 #define INTEL_815_APCONT 0x51
36 #define INTEL_815_ATTBASE_MASK ~0x1FFFFFFF
38 /* Intel i820 registers */
39 #define INTEL_I820_RDCR 0x51
40 #define INTEL_I820_ERRSTS 0xc8
42 /* Intel i840 registers */
43 #define INTEL_I840_MCHCFG 0x50
44 #define INTEL_I840_ERRSTS 0xc8
46 /* Intel i850 registers */
47 #define INTEL_I850_MCHCFG 0x50
48 #define INTEL_I850_ERRSTS 0xc8
50 /* intel 915G registers */
51 #define I915_GMADDR 0x18
52 #define I915_MMADDR 0x10
53 #define I915_PTEADDR 0x1C
54 #define I915_GMCH_GMS_STOLEN_48M (0x6 << 4)
55 #define I915_GMCH_GMS_STOLEN_64M (0x7 << 4)
57 /* Intel 965G registers */
58 #define I965_MSAC 0x62
60 /* Intel 7505 registers */
61 #define INTEL_I7505_APSIZE 0x74
62 #define INTEL_I7505_NCAPID 0x60
63 #define INTEL_I7505_NISTAT 0x6c
64 #define INTEL_I7505_ATTBASE 0x78
65 #define INTEL_I7505_ERRSTS 0x42
66 #define INTEL_I7505_AGPCTRL 0x70
67 #define INTEL_I7505_MCHCFG 0x50
69 static const struct aper_size_info_fixed intel_i810_sizes
[] =
72 /* The 32M mode still requires a 64k gatt */
76 #define AGP_DCACHE_MEMORY 1
77 #define AGP_PHYS_MEMORY 2
78 #define INTEL_AGP_CACHED_MEMORY 3
80 static struct gatt_mask intel_i810_masks
[] =
82 {.mask
= I810_PTE_VALID
, .type
= 0},
83 {.mask
= (I810_PTE_VALID
| I810_PTE_LOCAL
), .type
= AGP_DCACHE_MEMORY
},
84 {.mask
= I810_PTE_VALID
, .type
= 0},
85 {.mask
= I810_PTE_VALID
| I830_PTE_SYSTEM_CACHED
,
86 .type
= INTEL_AGP_CACHED_MEMORY
}
89 static struct _intel_private
{
90 struct pci_dev
*pcidev
; /* device one */
91 u8 __iomem
*registers
;
92 u32 __iomem
*gtt
; /* I915G */
93 int num_dcache_entries
;
94 /* gtt_entries is the number of gtt entries that are already mapped
95 * to stolen memory. Stolen memory is larger than the memory mapped
96 * through gtt_entries, as it includes some reserved space for the BIOS
97 * popup and for the GTT.
99 int gtt_entries
; /* i830+ */
102 static int intel_i810_fetch_size(void)
105 struct aper_size_info_fixed
*values
;
107 pci_read_config_dword(agp_bridge
->dev
, I810_SMRAM_MISCC
, &smram_miscc
);
108 values
= A_SIZE_FIX(agp_bridge
->driver
->aperture_sizes
);
110 if ((smram_miscc
& I810_GMS
) == I810_GMS_DISABLE
) {
111 printk(KERN_WARNING PFX
"i810 is disabled\n");
114 if ((smram_miscc
& I810_GFX_MEM_WIN_SIZE
) == I810_GFX_MEM_WIN_32M
) {
115 agp_bridge
->previous_size
=
116 agp_bridge
->current_size
= (void *) (values
+ 1);
117 agp_bridge
->aperture_size_idx
= 1;
118 return values
[1].size
;
120 agp_bridge
->previous_size
=
121 agp_bridge
->current_size
= (void *) (values
);
122 agp_bridge
->aperture_size_idx
= 0;
123 return values
[0].size
;
129 static int intel_i810_configure(void)
131 struct aper_size_info_fixed
*current_size
;
135 current_size
= A_SIZE_FIX(agp_bridge
->current_size
);
137 if (!intel_private
.registers
) {
138 pci_read_config_dword(intel_private
.pcidev
, I810_MMADDR
, &temp
);
141 intel_private
.registers
= ioremap(temp
, 128 * 4096);
142 if (!intel_private
.registers
) {
143 printk(KERN_ERR PFX
"Unable to remap memory.\n");
148 if ((readl(intel_private
.registers
+I810_DRAM_CTL
)
149 & I810_DRAM_ROW_0
) == I810_DRAM_ROW_0_SDRAM
) {
150 /* This will need to be dynamically assigned */
151 printk(KERN_INFO PFX
"detected 4MB dedicated video ram.\n");
152 intel_private
.num_dcache_entries
= 1024;
154 pci_read_config_dword(intel_private
.pcidev
, I810_GMADDR
, &temp
);
155 agp_bridge
->gart_bus_addr
= (temp
& PCI_BASE_ADDRESS_MEM_MASK
);
156 writel(agp_bridge
->gatt_bus_addr
| I810_PGETBL_ENABLED
, intel_private
.registers
+I810_PGETBL_CTL
);
157 readl(intel_private
.registers
+I810_PGETBL_CTL
); /* PCI Posting. */
159 if (agp_bridge
->driver
->needs_scratch_page
) {
160 for (i
= 0; i
< current_size
->num_entries
; i
++) {
161 writel(agp_bridge
->scratch_page
, intel_private
.registers
+I810_PTE_BASE
+(i
*4));
162 readl(intel_private
.registers
+I810_PTE_BASE
+(i
*4)); /* PCI posting. */
165 global_cache_flush();
169 static void intel_i810_cleanup(void)
171 writel(0, intel_private
.registers
+I810_PGETBL_CTL
);
172 readl(intel_private
.registers
); /* PCI Posting. */
173 iounmap(intel_private
.registers
);
176 static void intel_i810_tlbflush(struct agp_memory
*mem
)
181 static void intel_i810_agp_enable(struct agp_bridge_data
*bridge
, u32 mode
)
186 /* Exists to support ARGB cursors */
187 static void *i8xx_alloc_pages(void)
191 page
= alloc_pages(GFP_KERNEL
| GFP_DMA32
, 2);
195 if (change_page_attr(page
, 4, PAGE_KERNEL_NOCACHE
) < 0) {
196 change_page_attr(page
, 4, PAGE_KERNEL
);
198 __free_pages(page
, 2);
204 atomic_inc(&agp_bridge
->current_memory_agp
);
205 return page_address(page
);
208 static void i8xx_destroy_pages(void *addr
)
215 page
= virt_to_page(addr
);
216 change_page_attr(page
, 4, PAGE_KERNEL
);
220 __free_pages(page
, 2);
221 atomic_dec(&agp_bridge
->current_memory_agp
);
224 static int intel_i830_type_to_mask_type(struct agp_bridge_data
*bridge
,
227 if (type
< AGP_USER_TYPES
)
229 else if (type
== AGP_USER_CACHED_MEMORY
)
230 return INTEL_AGP_CACHED_MEMORY
;
235 static int intel_i810_insert_entries(struct agp_memory
*mem
, off_t pg_start
,
238 int i
, j
, num_entries
;
243 if (mem
->page_count
== 0)
246 temp
= agp_bridge
->current_size
;
247 num_entries
= A_SIZE_FIX(temp
)->num_entries
;
249 if ((pg_start
+ mem
->page_count
) > num_entries
)
253 for (j
= pg_start
; j
< (pg_start
+ mem
->page_count
); j
++) {
254 if (!PGE_EMPTY(agp_bridge
, readl(agp_bridge
->gatt_table
+j
))) {
260 if (type
!= mem
->type
)
263 mask_type
= agp_bridge
->driver
->agp_type_to_mask_type(agp_bridge
, type
);
266 case AGP_DCACHE_MEMORY
:
267 if (!mem
->is_flushed
)
268 global_cache_flush();
269 for (i
= pg_start
; i
< (pg_start
+ mem
->page_count
); i
++) {
270 writel((i
*4096)|I810_PTE_LOCAL
|I810_PTE_VALID
,
271 intel_private
.registers
+I810_PTE_BASE
+(i
*4));
273 readl(intel_private
.registers
+I810_PTE_BASE
+((i
-1)*4));
275 case AGP_PHYS_MEMORY
:
276 case AGP_NORMAL_MEMORY
:
277 if (!mem
->is_flushed
)
278 global_cache_flush();
279 for (i
= 0, j
= pg_start
; i
< mem
->page_count
; i
++, j
++) {
280 writel(agp_bridge
->driver
->mask_memory(agp_bridge
,
283 intel_private
.registers
+I810_PTE_BASE
+(j
*4));
285 readl(intel_private
.registers
+I810_PTE_BASE
+((j
-1)*4));
291 agp_bridge
->driver
->tlb_flush(mem
);
299 static int intel_i810_remove_entries(struct agp_memory
*mem
, off_t pg_start
,
304 if (mem
->page_count
== 0)
307 for (i
= pg_start
; i
< (mem
->page_count
+ pg_start
); i
++) {
308 writel(agp_bridge
->scratch_page
, intel_private
.registers
+I810_PTE_BASE
+(i
*4));
310 readl(intel_private
.registers
+I810_PTE_BASE
+((i
-1)*4));
312 agp_bridge
->driver
->tlb_flush(mem
);
317 * The i810/i830 requires a physical address to program its mouse
318 * pointer into hardware.
319 * However the Xserver still writes to it through the agp aperture.
321 static struct agp_memory
*alloc_agpphysmem_i8xx(size_t pg_count
, int type
)
323 struct agp_memory
*new;
327 case 1: addr
= agp_bridge
->driver
->agp_alloc_page(agp_bridge
);
331 /* kludge to get 4 physical pages for ARGB cursor */
332 addr
= i8xx_alloc_pages();
341 new = agp_create_memory(pg_count
);
345 new->memory
[0] = virt_to_gart(addr
);
347 /* kludge to get 4 physical pages for ARGB cursor */
348 new->memory
[1] = new->memory
[0] + PAGE_SIZE
;
349 new->memory
[2] = new->memory
[1] + PAGE_SIZE
;
350 new->memory
[3] = new->memory
[2] + PAGE_SIZE
;
352 new->page_count
= pg_count
;
353 new->num_scratch_pages
= pg_count
;
354 new->type
= AGP_PHYS_MEMORY
;
355 new->physical
= new->memory
[0];
359 static struct agp_memory
*intel_i810_alloc_by_type(size_t pg_count
, int type
)
361 struct agp_memory
*new;
363 if (type
== AGP_DCACHE_MEMORY
) {
364 if (pg_count
!= intel_private
.num_dcache_entries
)
367 new = agp_create_memory(1);
371 new->type
= AGP_DCACHE_MEMORY
;
372 new->page_count
= pg_count
;
373 new->num_scratch_pages
= 0;
374 agp_free_page_array(new);
377 if (type
== AGP_PHYS_MEMORY
)
378 return alloc_agpphysmem_i8xx(pg_count
, type
);
382 static void intel_i810_free_by_type(struct agp_memory
*curr
)
384 agp_free_key(curr
->key
);
385 if (curr
->type
== AGP_PHYS_MEMORY
) {
386 if (curr
->page_count
== 4)
387 i8xx_destroy_pages(gart_to_virt(curr
->memory
[0]));
389 agp_bridge
->driver
->agp_destroy_page(
390 gart_to_virt(curr
->memory
[0]));
393 agp_free_page_array(curr
);
398 static unsigned long intel_i810_mask_memory(struct agp_bridge_data
*bridge
,
399 unsigned long addr
, int type
)
401 /* Type checking must be done elsewhere */
402 return addr
| bridge
->driver
->masks
[type
].mask
;
405 static struct aper_size_info_fixed intel_i830_sizes
[] =
408 /* The 64M mode still requires a 128k gatt */
414 static void intel_i830_init_gtt_entries(void)
420 static const int ddt
[4] = { 0, 16, 32, 64 };
421 int size
; /* reserved space (in kb) at the top of stolen memory */
423 pci_read_config_word(agp_bridge
->dev
,I830_GMCH_CTRL
,&gmch_ctrl
);
427 pgetbl_ctl
= readl(intel_private
.registers
+I810_PGETBL_CTL
);
429 /* The 965 has a field telling us the size of the GTT,
430 * which may be larger than what is necessary to map the
433 switch (pgetbl_ctl
& I965_PGETBL_SIZE_MASK
) {
434 case I965_PGETBL_SIZE_128KB
:
437 case I965_PGETBL_SIZE_256KB
:
440 case I965_PGETBL_SIZE_512KB
:
444 printk(KERN_INFO PFX
"Unknown page table size, "
448 size
+= 4; /* add in BIOS popup space */
450 /* On previous hardware, the GTT size was just what was
451 * required to map the aperture.
453 size
= agp_bridge
->driver
->fetch_size() + 4;
456 if (agp_bridge
->dev
->device
== PCI_DEVICE_ID_INTEL_82830_HB
||
457 agp_bridge
->dev
->device
== PCI_DEVICE_ID_INTEL_82845G_HB
) {
458 switch (gmch_ctrl
& I830_GMCH_GMS_MASK
) {
459 case I830_GMCH_GMS_STOLEN_512
:
460 gtt_entries
= KB(512) - KB(size
);
462 case I830_GMCH_GMS_STOLEN_1024
:
463 gtt_entries
= MB(1) - KB(size
);
465 case I830_GMCH_GMS_STOLEN_8192
:
466 gtt_entries
= MB(8) - KB(size
);
468 case I830_GMCH_GMS_LOCAL
:
469 rdct
= readb(intel_private
.registers
+I830_RDRAM_CHANNEL_TYPE
);
470 gtt_entries
= (I830_RDRAM_ND(rdct
) + 1) *
471 MB(ddt
[I830_RDRAM_DDT(rdct
)]);
479 switch (gmch_ctrl
& I830_GMCH_GMS_MASK
) {
480 case I855_GMCH_GMS_STOLEN_1M
:
481 gtt_entries
= MB(1) - KB(size
);
483 case I855_GMCH_GMS_STOLEN_4M
:
484 gtt_entries
= MB(4) - KB(size
);
486 case I855_GMCH_GMS_STOLEN_8M
:
487 gtt_entries
= MB(8) - KB(size
);
489 case I855_GMCH_GMS_STOLEN_16M
:
490 gtt_entries
= MB(16) - KB(size
);
492 case I855_GMCH_GMS_STOLEN_32M
:
493 gtt_entries
= MB(32) - KB(size
);
495 case I915_GMCH_GMS_STOLEN_48M
:
496 /* Check it's really I915G */
497 if (agp_bridge
->dev
->device
== PCI_DEVICE_ID_INTEL_82915G_HB
||
498 agp_bridge
->dev
->device
== PCI_DEVICE_ID_INTEL_82915GM_HB
||
499 agp_bridge
->dev
->device
== PCI_DEVICE_ID_INTEL_82945G_HB
||
500 agp_bridge
->dev
->device
== PCI_DEVICE_ID_INTEL_82945GM_HB
|| IS_I965
)
501 gtt_entries
= MB(48) - KB(size
);
505 case I915_GMCH_GMS_STOLEN_64M
:
506 /* Check it's really I915G */
507 if (agp_bridge
->dev
->device
== PCI_DEVICE_ID_INTEL_82915G_HB
||
508 agp_bridge
->dev
->device
== PCI_DEVICE_ID_INTEL_82915GM_HB
||
509 agp_bridge
->dev
->device
== PCI_DEVICE_ID_INTEL_82945G_HB
||
510 agp_bridge
->dev
->device
== PCI_DEVICE_ID_INTEL_82945GM_HB
|| IS_I965
)
511 gtt_entries
= MB(64) - KB(size
);
520 printk(KERN_INFO PFX
"Detected %dK %s memory.\n",
521 gtt_entries
/ KB(1), local
? "local" : "stolen");
524 "No pre-allocated video memory detected.\n");
525 gtt_entries
/= KB(4);
527 intel_private
.gtt_entries
= gtt_entries
;
530 /* The intel i830 automatically initializes the agp aperture during POST.
531 * Use the memory already set aside for in the GTT.
533 static int intel_i830_create_gatt_table(struct agp_bridge_data
*bridge
)
536 struct aper_size_info_fixed
*size
;
540 size
= agp_bridge
->current_size
;
541 page_order
= size
->page_order
;
542 num_entries
= size
->num_entries
;
543 agp_bridge
->gatt_table_real
= NULL
;
545 pci_read_config_dword(intel_private
.pcidev
,I810_MMADDR
,&temp
);
548 intel_private
.registers
= ioremap(temp
,128 * 4096);
549 if (!intel_private
.registers
)
552 temp
= readl(intel_private
.registers
+I810_PGETBL_CTL
) & 0xfffff000;
553 global_cache_flush(); /* FIXME: ?? */
555 /* we have to call this as early as possible after the MMIO base address is known */
556 intel_i830_init_gtt_entries();
558 agp_bridge
->gatt_table
= NULL
;
560 agp_bridge
->gatt_bus_addr
= temp
;
565 /* Return the gatt table to a sane state. Use the top of stolen
566 * memory for the GTT.
568 static int intel_i830_free_gatt_table(struct agp_bridge_data
*bridge
)
573 static int intel_i830_fetch_size(void)
576 struct aper_size_info_fixed
*values
;
578 values
= A_SIZE_FIX(agp_bridge
->driver
->aperture_sizes
);
580 if (agp_bridge
->dev
->device
!= PCI_DEVICE_ID_INTEL_82830_HB
&&
581 agp_bridge
->dev
->device
!= PCI_DEVICE_ID_INTEL_82845G_HB
) {
582 /* 855GM/852GM/865G has 128MB aperture size */
583 agp_bridge
->previous_size
= agp_bridge
->current_size
= (void *) values
;
584 agp_bridge
->aperture_size_idx
= 0;
585 return values
[0].size
;
588 pci_read_config_word(agp_bridge
->dev
,I830_GMCH_CTRL
,&gmch_ctrl
);
590 if ((gmch_ctrl
& I830_GMCH_MEM_MASK
) == I830_GMCH_MEM_128M
) {
591 agp_bridge
->previous_size
= agp_bridge
->current_size
= (void *) values
;
592 agp_bridge
->aperture_size_idx
= 0;
593 return values
[0].size
;
595 agp_bridge
->previous_size
= agp_bridge
->current_size
= (void *) (values
+ 1);
596 agp_bridge
->aperture_size_idx
= 1;
597 return values
[1].size
;
603 static int intel_i830_configure(void)
605 struct aper_size_info_fixed
*current_size
;
610 current_size
= A_SIZE_FIX(agp_bridge
->current_size
);
612 pci_read_config_dword(intel_private
.pcidev
,I810_GMADDR
,&temp
);
613 agp_bridge
->gart_bus_addr
= (temp
& PCI_BASE_ADDRESS_MEM_MASK
);
615 pci_read_config_word(agp_bridge
->dev
,I830_GMCH_CTRL
,&gmch_ctrl
);
616 gmch_ctrl
|= I830_GMCH_ENABLED
;
617 pci_write_config_word(agp_bridge
->dev
,I830_GMCH_CTRL
,gmch_ctrl
);
619 writel(agp_bridge
->gatt_bus_addr
|I810_PGETBL_ENABLED
, intel_private
.registers
+I810_PGETBL_CTL
);
620 readl(intel_private
.registers
+I810_PGETBL_CTL
); /* PCI Posting. */
622 if (agp_bridge
->driver
->needs_scratch_page
) {
623 for (i
= intel_private
.gtt_entries
; i
< current_size
->num_entries
; i
++) {
624 writel(agp_bridge
->scratch_page
, intel_private
.registers
+I810_PTE_BASE
+(i
*4));
625 readl(intel_private
.registers
+I810_PTE_BASE
+(i
*4)); /* PCI Posting. */
629 global_cache_flush();
633 static void intel_i830_cleanup(void)
635 iounmap(intel_private
.registers
);
638 static int intel_i830_insert_entries(struct agp_memory
*mem
,off_t pg_start
, int type
)
645 if (mem
->page_count
== 0)
648 temp
= agp_bridge
->current_size
;
649 num_entries
= A_SIZE_FIX(temp
)->num_entries
;
651 if (pg_start
< intel_private
.gtt_entries
) {
652 printk (KERN_DEBUG PFX
"pg_start == 0x%.8lx,intel_private.gtt_entries == 0x%.8x\n",
653 pg_start
,intel_private
.gtt_entries
);
655 printk (KERN_INFO PFX
"Trying to insert into local/stolen memory\n");
659 if ((pg_start
+ mem
->page_count
) > num_entries
)
662 /* The i830 can't check the GTT for entries since its read only,
663 * depend on the caller to make the correct offset decisions.
666 if (type
!= mem
->type
)
669 mask_type
= agp_bridge
->driver
->agp_type_to_mask_type(agp_bridge
, type
);
671 if (mask_type
!= 0 && mask_type
!= AGP_PHYS_MEMORY
&&
672 mask_type
!= INTEL_AGP_CACHED_MEMORY
)
675 if (!mem
->is_flushed
)
676 global_cache_flush();
678 for (i
= 0, j
= pg_start
; i
< mem
->page_count
; i
++, j
++) {
679 writel(agp_bridge
->driver
->mask_memory(agp_bridge
,
680 mem
->memory
[i
], mask_type
),
681 intel_private
.registers
+I810_PTE_BASE
+(j
*4));
683 readl(intel_private
.registers
+I810_PTE_BASE
+((j
-1)*4));
684 agp_bridge
->driver
->tlb_flush(mem
);
693 static int intel_i830_remove_entries(struct agp_memory
*mem
,off_t pg_start
,
698 if (mem
->page_count
== 0)
701 if (pg_start
< intel_private
.gtt_entries
) {
702 printk (KERN_INFO PFX
"Trying to disable local/stolen memory\n");
706 for (i
= pg_start
; i
< (mem
->page_count
+ pg_start
); i
++) {
707 writel(agp_bridge
->scratch_page
, intel_private
.registers
+I810_PTE_BASE
+(i
*4));
709 readl(intel_private
.registers
+I810_PTE_BASE
+((i
-1)*4));
711 agp_bridge
->driver
->tlb_flush(mem
);
715 static struct agp_memory
*intel_i830_alloc_by_type(size_t pg_count
,int type
)
717 if (type
== AGP_PHYS_MEMORY
)
718 return alloc_agpphysmem_i8xx(pg_count
, type
);
719 /* always return NULL for other allocation types for now */
723 static int intel_i915_configure(void)
725 struct aper_size_info_fixed
*current_size
;
730 current_size
= A_SIZE_FIX(agp_bridge
->current_size
);
732 pci_read_config_dword(intel_private
.pcidev
, I915_GMADDR
, &temp
);
734 agp_bridge
->gart_bus_addr
= (temp
& PCI_BASE_ADDRESS_MEM_MASK
);
736 pci_read_config_word(agp_bridge
->dev
,I830_GMCH_CTRL
,&gmch_ctrl
);
737 gmch_ctrl
|= I830_GMCH_ENABLED
;
738 pci_write_config_word(agp_bridge
->dev
,I830_GMCH_CTRL
,gmch_ctrl
);
740 writel(agp_bridge
->gatt_bus_addr
|I810_PGETBL_ENABLED
, intel_private
.registers
+I810_PGETBL_CTL
);
741 readl(intel_private
.registers
+I810_PGETBL_CTL
); /* PCI Posting. */
743 if (agp_bridge
->driver
->needs_scratch_page
) {
744 for (i
= intel_private
.gtt_entries
; i
< current_size
->num_entries
; i
++) {
745 writel(agp_bridge
->scratch_page
, intel_private
.gtt
+i
);
746 readl(intel_private
.gtt
+i
); /* PCI Posting. */
750 global_cache_flush();
754 static void intel_i915_cleanup(void)
756 iounmap(intel_private
.gtt
);
757 iounmap(intel_private
.registers
);
760 static int intel_i915_insert_entries(struct agp_memory
*mem
,off_t pg_start
,
768 if (mem
->page_count
== 0)
771 temp
= agp_bridge
->current_size
;
772 num_entries
= A_SIZE_FIX(temp
)->num_entries
;
774 if (pg_start
< intel_private
.gtt_entries
) {
775 printk (KERN_DEBUG PFX
"pg_start == 0x%.8lx,intel_private.gtt_entries == 0x%.8x\n",
776 pg_start
,intel_private
.gtt_entries
);
778 printk (KERN_INFO PFX
"Trying to insert into local/stolen memory\n");
782 if ((pg_start
+ mem
->page_count
) > num_entries
)
785 /* The i915 can't check the GTT for entries since its read only,
786 * depend on the caller to make the correct offset decisions.
789 if (type
!= mem
->type
)
792 mask_type
= agp_bridge
->driver
->agp_type_to_mask_type(agp_bridge
, type
);
794 if (mask_type
!= 0 && mask_type
!= AGP_PHYS_MEMORY
&&
795 mask_type
!= INTEL_AGP_CACHED_MEMORY
)
798 if (!mem
->is_flushed
)
799 global_cache_flush();
801 for (i
= 0, j
= pg_start
; i
< mem
->page_count
; i
++, j
++) {
802 writel(agp_bridge
->driver
->mask_memory(agp_bridge
,
803 mem
->memory
[i
], mask_type
), intel_private
.gtt
+j
);
806 readl(intel_private
.gtt
+j
-1);
807 agp_bridge
->driver
->tlb_flush(mem
);
816 static int intel_i915_remove_entries(struct agp_memory
*mem
,off_t pg_start
,
821 if (mem
->page_count
== 0)
824 if (pg_start
< intel_private
.gtt_entries
) {
825 printk (KERN_INFO PFX
"Trying to disable local/stolen memory\n");
829 for (i
= pg_start
; i
< (mem
->page_count
+ pg_start
); i
++) {
830 writel(agp_bridge
->scratch_page
, intel_private
.gtt
+i
);
832 readl(intel_private
.gtt
+i
-1);
834 agp_bridge
->driver
->tlb_flush(mem
);
838 /* Return the aperture size by just checking the resource length. The effect
839 * described in the spec of the MSAC registers is just changing of the
842 static int intel_i9xx_fetch_size(void)
844 int num_sizes
= ARRAY_SIZE(intel_i830_sizes
);
845 int aper_size
; /* size in megabytes */
848 aper_size
= pci_resource_len(intel_private
.pcidev
, 2) / MB(1);
850 for (i
= 0; i
< num_sizes
; i
++) {
851 if (aper_size
== intel_i830_sizes
[i
].size
) {
852 agp_bridge
->current_size
= intel_i830_sizes
+ i
;
853 agp_bridge
->previous_size
= agp_bridge
->current_size
;
861 /* The intel i915 automatically initializes the agp aperture during POST.
862 * Use the memory already set aside for in the GTT.
864 static int intel_i915_create_gatt_table(struct agp_bridge_data
*bridge
)
867 struct aper_size_info_fixed
*size
;
871 size
= agp_bridge
->current_size
;
872 page_order
= size
->page_order
;
873 num_entries
= size
->num_entries
;
874 agp_bridge
->gatt_table_real
= NULL
;
876 pci_read_config_dword(intel_private
.pcidev
, I915_MMADDR
, &temp
);
877 pci_read_config_dword(intel_private
.pcidev
, I915_PTEADDR
,&temp2
);
879 intel_private
.gtt
= ioremap(temp2
, 256 * 1024);
880 if (!intel_private
.gtt
)
885 intel_private
.registers
= ioremap(temp
,128 * 4096);
886 if (!intel_private
.registers
)
889 temp
= readl(intel_private
.registers
+I810_PGETBL_CTL
) & 0xfffff000;
890 global_cache_flush(); /* FIXME: ? */
892 /* we have to call this as early as possible after the MMIO base address is known */
893 intel_i830_init_gtt_entries();
895 agp_bridge
->gatt_table
= NULL
;
897 agp_bridge
->gatt_bus_addr
= temp
;
903 * The i965 supports 36-bit physical addresses, but to keep
904 * the format of the GTT the same, the bits that don't fit
905 * in a 32-bit word are shifted down to bits 4..7.
907 * Gcc is smart enough to notice that "(addr >> 28) & 0xf0"
908 * is always zero on 32-bit architectures, so no need to make
911 static unsigned long intel_i965_mask_memory(struct agp_bridge_data
*bridge
,
912 unsigned long addr
, int type
)
914 /* Shift high bits down */
915 addr
|= (addr
>> 28) & 0xf0;
917 /* Type checking must be done elsewhere */
918 return addr
| bridge
->driver
->masks
[type
].mask
;
921 /* The intel i965 automatically initializes the agp aperture during POST.
922 * Use the memory already set aside for in the GTT.
924 static int intel_i965_create_gatt_table(struct agp_bridge_data
*bridge
)
927 struct aper_size_info_fixed
*size
;
931 size
= agp_bridge
->current_size
;
932 page_order
= size
->page_order
;
933 num_entries
= size
->num_entries
;
934 agp_bridge
->gatt_table_real
= NULL
;
936 pci_read_config_dword(intel_private
.pcidev
, I915_MMADDR
, &temp
);
939 intel_private
.gtt
= ioremap((temp
+ (512 * 1024)) , 512 * 1024);
941 if (!intel_private
.gtt
)
945 intel_private
.registers
= ioremap(temp
,128 * 4096);
946 if (!intel_private
.registers
)
949 temp
= readl(intel_private
.registers
+I810_PGETBL_CTL
) & 0xfffff000;
950 global_cache_flush(); /* FIXME: ? */
952 /* we have to call this as early as possible after the MMIO base address is known */
953 intel_i830_init_gtt_entries();
955 agp_bridge
->gatt_table
= NULL
;
957 agp_bridge
->gatt_bus_addr
= temp
;
963 static int intel_fetch_size(void)
967 struct aper_size_info_16
*values
;
969 pci_read_config_word(agp_bridge
->dev
, INTEL_APSIZE
, &temp
);
970 values
= A_SIZE_16(agp_bridge
->driver
->aperture_sizes
);
972 for (i
= 0; i
< agp_bridge
->driver
->num_aperture_sizes
; i
++) {
973 if (temp
== values
[i
].size_value
) {
974 agp_bridge
->previous_size
= agp_bridge
->current_size
= (void *) (values
+ i
);
975 agp_bridge
->aperture_size_idx
= i
;
976 return values
[i
].size
;
983 static int __intel_8xx_fetch_size(u8 temp
)
986 struct aper_size_info_8
*values
;
988 values
= A_SIZE_8(agp_bridge
->driver
->aperture_sizes
);
990 for (i
= 0; i
< agp_bridge
->driver
->num_aperture_sizes
; i
++) {
991 if (temp
== values
[i
].size_value
) {
992 agp_bridge
->previous_size
=
993 agp_bridge
->current_size
= (void *) (values
+ i
);
994 agp_bridge
->aperture_size_idx
= i
;
995 return values
[i
].size
;
1001 static int intel_8xx_fetch_size(void)
1005 pci_read_config_byte(agp_bridge
->dev
, INTEL_APSIZE
, &temp
);
1006 return __intel_8xx_fetch_size(temp
);
1009 static int intel_815_fetch_size(void)
1013 /* Intel 815 chipsets have a _weird_ APSIZE register with only
1014 * one non-reserved bit, so mask the others out ... */
1015 pci_read_config_byte(agp_bridge
->dev
, INTEL_APSIZE
, &temp
);
1018 return __intel_8xx_fetch_size(temp
);
1021 static void intel_tlbflush(struct agp_memory
*mem
)
1023 pci_write_config_dword(agp_bridge
->dev
, INTEL_AGPCTRL
, 0x2200);
1024 pci_write_config_dword(agp_bridge
->dev
, INTEL_AGPCTRL
, 0x2280);
1028 static void intel_8xx_tlbflush(struct agp_memory
*mem
)
1031 pci_read_config_dword(agp_bridge
->dev
, INTEL_AGPCTRL
, &temp
);
1032 pci_write_config_dword(agp_bridge
->dev
, INTEL_AGPCTRL
, temp
& ~(1 << 7));
1033 pci_read_config_dword(agp_bridge
->dev
, INTEL_AGPCTRL
, &temp
);
1034 pci_write_config_dword(agp_bridge
->dev
, INTEL_AGPCTRL
, temp
| (1 << 7));
1038 static void intel_cleanup(void)
1041 struct aper_size_info_16
*previous_size
;
1043 previous_size
= A_SIZE_16(agp_bridge
->previous_size
);
1044 pci_read_config_word(agp_bridge
->dev
, INTEL_NBXCFG
, &temp
);
1045 pci_write_config_word(agp_bridge
->dev
, INTEL_NBXCFG
, temp
& ~(1 << 9));
1046 pci_write_config_word(agp_bridge
->dev
, INTEL_APSIZE
, previous_size
->size_value
);
1050 static void intel_8xx_cleanup(void)
1053 struct aper_size_info_8
*previous_size
;
1055 previous_size
= A_SIZE_8(agp_bridge
->previous_size
);
1056 pci_read_config_word(agp_bridge
->dev
, INTEL_NBXCFG
, &temp
);
1057 pci_write_config_word(agp_bridge
->dev
, INTEL_NBXCFG
, temp
& ~(1 << 9));
1058 pci_write_config_byte(agp_bridge
->dev
, INTEL_APSIZE
, previous_size
->size_value
);
1062 static int intel_configure(void)
1066 struct aper_size_info_16
*current_size
;
1068 current_size
= A_SIZE_16(agp_bridge
->current_size
);
1071 pci_write_config_word(agp_bridge
->dev
, INTEL_APSIZE
, current_size
->size_value
);
1073 /* address to map to */
1074 pci_read_config_dword(agp_bridge
->dev
, AGP_APBASE
, &temp
);
1075 agp_bridge
->gart_bus_addr
= (temp
& PCI_BASE_ADDRESS_MEM_MASK
);
1077 /* attbase - aperture base */
1078 pci_write_config_dword(agp_bridge
->dev
, INTEL_ATTBASE
, agp_bridge
->gatt_bus_addr
);
1081 pci_write_config_dword(agp_bridge
->dev
, INTEL_AGPCTRL
, 0x2280);
1084 pci_read_config_word(agp_bridge
->dev
, INTEL_NBXCFG
, &temp2
);
1085 pci_write_config_word(agp_bridge
->dev
, INTEL_NBXCFG
,
1086 (temp2
& ~(1 << 10)) | (1 << 9));
1087 /* clear any possible error conditions */
1088 pci_write_config_byte(agp_bridge
->dev
, INTEL_ERRSTS
+ 1, 7);
1092 static int intel_815_configure(void)
1096 struct aper_size_info_8
*current_size
;
1098 /* attbase - aperture base */
1099 /* the Intel 815 chipset spec. says that bits 29-31 in the
1100 * ATTBASE register are reserved -> try not to write them */
1101 if (agp_bridge
->gatt_bus_addr
& INTEL_815_ATTBASE_MASK
) {
1102 printk (KERN_EMERG PFX
"gatt bus addr too high");
1106 current_size
= A_SIZE_8(agp_bridge
->current_size
);
1109 pci_write_config_byte(agp_bridge
->dev
, INTEL_APSIZE
,
1110 current_size
->size_value
);
1112 /* address to map to */
1113 pci_read_config_dword(agp_bridge
->dev
, AGP_APBASE
, &temp
);
1114 agp_bridge
->gart_bus_addr
= (temp
& PCI_BASE_ADDRESS_MEM_MASK
);
1116 pci_read_config_dword(agp_bridge
->dev
, INTEL_ATTBASE
, &addr
);
1117 addr
&= INTEL_815_ATTBASE_MASK
;
1118 addr
|= agp_bridge
->gatt_bus_addr
;
1119 pci_write_config_dword(agp_bridge
->dev
, INTEL_ATTBASE
, addr
);
1122 pci_write_config_dword(agp_bridge
->dev
, INTEL_AGPCTRL
, 0x0000);
1125 pci_read_config_byte(agp_bridge
->dev
, INTEL_815_APCONT
, &temp2
);
1126 pci_write_config_byte(agp_bridge
->dev
, INTEL_815_APCONT
, temp2
| (1 << 1));
1128 /* clear any possible error conditions */
1129 /* Oddness : this chipset seems to have no ERRSTS register ! */
1133 static void intel_820_tlbflush(struct agp_memory
*mem
)
1138 static void intel_820_cleanup(void)
1141 struct aper_size_info_8
*previous_size
;
1143 previous_size
= A_SIZE_8(agp_bridge
->previous_size
);
1144 pci_read_config_byte(agp_bridge
->dev
, INTEL_I820_RDCR
, &temp
);
1145 pci_write_config_byte(agp_bridge
->dev
, INTEL_I820_RDCR
,
1147 pci_write_config_byte(agp_bridge
->dev
, INTEL_APSIZE
,
1148 previous_size
->size_value
);
1152 static int intel_820_configure(void)
1156 struct aper_size_info_8
*current_size
;
1158 current_size
= A_SIZE_8(agp_bridge
->current_size
);
1161 pci_write_config_byte(agp_bridge
->dev
, INTEL_APSIZE
, current_size
->size_value
);
1163 /* address to map to */
1164 pci_read_config_dword(agp_bridge
->dev
, AGP_APBASE
, &temp
);
1165 agp_bridge
->gart_bus_addr
= (temp
& PCI_BASE_ADDRESS_MEM_MASK
);
1167 /* attbase - aperture base */
1168 pci_write_config_dword(agp_bridge
->dev
, INTEL_ATTBASE
, agp_bridge
->gatt_bus_addr
);
1171 pci_write_config_dword(agp_bridge
->dev
, INTEL_AGPCTRL
, 0x0000);
1173 /* global enable aperture access */
1174 /* This flag is not accessed through MCHCFG register as in */
1176 pci_read_config_byte(agp_bridge
->dev
, INTEL_I820_RDCR
, &temp2
);
1177 pci_write_config_byte(agp_bridge
->dev
, INTEL_I820_RDCR
, temp2
| (1 << 1));
1178 /* clear any possible AGP-related error conditions */
1179 pci_write_config_word(agp_bridge
->dev
, INTEL_I820_ERRSTS
, 0x001c);
1183 static int intel_840_configure(void)
1187 struct aper_size_info_8
*current_size
;
1189 current_size
= A_SIZE_8(agp_bridge
->current_size
);
1192 pci_write_config_byte(agp_bridge
->dev
, INTEL_APSIZE
, current_size
->size_value
);
1194 /* address to map to */
1195 pci_read_config_dword(agp_bridge
->dev
, AGP_APBASE
, &temp
);
1196 agp_bridge
->gart_bus_addr
= (temp
& PCI_BASE_ADDRESS_MEM_MASK
);
1198 /* attbase - aperture base */
1199 pci_write_config_dword(agp_bridge
->dev
, INTEL_ATTBASE
, agp_bridge
->gatt_bus_addr
);
1202 pci_write_config_dword(agp_bridge
->dev
, INTEL_AGPCTRL
, 0x0000);
1205 pci_read_config_word(agp_bridge
->dev
, INTEL_I840_MCHCFG
, &temp2
);
1206 pci_write_config_word(agp_bridge
->dev
, INTEL_I840_MCHCFG
, temp2
| (1 << 9));
1207 /* clear any possible error conditions */
1208 pci_write_config_word(agp_bridge
->dev
, INTEL_I840_ERRSTS
, 0xc000);
1212 static int intel_845_configure(void)
1216 struct aper_size_info_8
*current_size
;
1218 current_size
= A_SIZE_8(agp_bridge
->current_size
);
1221 pci_write_config_byte(agp_bridge
->dev
, INTEL_APSIZE
, current_size
->size_value
);
1223 if (agp_bridge
->apbase_config
!= 0) {
1224 pci_write_config_dword(agp_bridge
->dev
, AGP_APBASE
,
1225 agp_bridge
->apbase_config
);
1227 /* address to map to */
1228 pci_read_config_dword(agp_bridge
->dev
, AGP_APBASE
, &temp
);
1229 agp_bridge
->gart_bus_addr
= (temp
& PCI_BASE_ADDRESS_MEM_MASK
);
1230 agp_bridge
->apbase_config
= temp
;
1233 /* attbase - aperture base */
1234 pci_write_config_dword(agp_bridge
->dev
, INTEL_ATTBASE
, agp_bridge
->gatt_bus_addr
);
1237 pci_write_config_dword(agp_bridge
->dev
, INTEL_AGPCTRL
, 0x0000);
1240 pci_read_config_byte(agp_bridge
->dev
, INTEL_I845_AGPM
, &temp2
);
1241 pci_write_config_byte(agp_bridge
->dev
, INTEL_I845_AGPM
, temp2
| (1 << 1));
1242 /* clear any possible error conditions */
1243 pci_write_config_word(agp_bridge
->dev
, INTEL_I845_ERRSTS
, 0x001c);
1247 static int intel_850_configure(void)
1251 struct aper_size_info_8
*current_size
;
1253 current_size
= A_SIZE_8(agp_bridge
->current_size
);
1256 pci_write_config_byte(agp_bridge
->dev
, INTEL_APSIZE
, current_size
->size_value
);
1258 /* address to map to */
1259 pci_read_config_dword(agp_bridge
->dev
, AGP_APBASE
, &temp
);
1260 agp_bridge
->gart_bus_addr
= (temp
& PCI_BASE_ADDRESS_MEM_MASK
);
1262 /* attbase - aperture base */
1263 pci_write_config_dword(agp_bridge
->dev
, INTEL_ATTBASE
, agp_bridge
->gatt_bus_addr
);
1266 pci_write_config_dword(agp_bridge
->dev
, INTEL_AGPCTRL
, 0x0000);
1269 pci_read_config_word(agp_bridge
->dev
, INTEL_I850_MCHCFG
, &temp2
);
1270 pci_write_config_word(agp_bridge
->dev
, INTEL_I850_MCHCFG
, temp2
| (1 << 9));
1271 /* clear any possible AGP-related error conditions */
1272 pci_write_config_word(agp_bridge
->dev
, INTEL_I850_ERRSTS
, 0x001c);
1276 static int intel_860_configure(void)
1280 struct aper_size_info_8
*current_size
;
1282 current_size
= A_SIZE_8(agp_bridge
->current_size
);
1285 pci_write_config_byte(agp_bridge
->dev
, INTEL_APSIZE
, current_size
->size_value
);
1287 /* address to map to */
1288 pci_read_config_dword(agp_bridge
->dev
, AGP_APBASE
, &temp
);
1289 agp_bridge
->gart_bus_addr
= (temp
& PCI_BASE_ADDRESS_MEM_MASK
);
1291 /* attbase - aperture base */
1292 pci_write_config_dword(agp_bridge
->dev
, INTEL_ATTBASE
, agp_bridge
->gatt_bus_addr
);
1295 pci_write_config_dword(agp_bridge
->dev
, INTEL_AGPCTRL
, 0x0000);
1298 pci_read_config_word(agp_bridge
->dev
, INTEL_I860_MCHCFG
, &temp2
);
1299 pci_write_config_word(agp_bridge
->dev
, INTEL_I860_MCHCFG
, temp2
| (1 << 9));
1300 /* clear any possible AGP-related error conditions */
1301 pci_write_config_word(agp_bridge
->dev
, INTEL_I860_ERRSTS
, 0xf700);
1305 static int intel_830mp_configure(void)
1309 struct aper_size_info_8
*current_size
;
1311 current_size
= A_SIZE_8(agp_bridge
->current_size
);
1314 pci_write_config_byte(agp_bridge
->dev
, INTEL_APSIZE
, current_size
->size_value
);
1316 /* address to map to */
1317 pci_read_config_dword(agp_bridge
->dev
, AGP_APBASE
, &temp
);
1318 agp_bridge
->gart_bus_addr
= (temp
& PCI_BASE_ADDRESS_MEM_MASK
);
1320 /* attbase - aperture base */
1321 pci_write_config_dword(agp_bridge
->dev
, INTEL_ATTBASE
, agp_bridge
->gatt_bus_addr
);
1324 pci_write_config_dword(agp_bridge
->dev
, INTEL_AGPCTRL
, 0x0000);
1327 pci_read_config_word(agp_bridge
->dev
, INTEL_NBXCFG
, &temp2
);
1328 pci_write_config_word(agp_bridge
->dev
, INTEL_NBXCFG
, temp2
| (1 << 9));
1329 /* clear any possible AGP-related error conditions */
1330 pci_write_config_word(agp_bridge
->dev
, INTEL_I830_ERRSTS
, 0x1c);
1334 static int intel_7505_configure(void)
1338 struct aper_size_info_8
*current_size
;
1340 current_size
= A_SIZE_8(agp_bridge
->current_size
);
1343 pci_write_config_byte(agp_bridge
->dev
, INTEL_APSIZE
, current_size
->size_value
);
1345 /* address to map to */
1346 pci_read_config_dword(agp_bridge
->dev
, AGP_APBASE
, &temp
);
1347 agp_bridge
->gart_bus_addr
= (temp
& PCI_BASE_ADDRESS_MEM_MASK
);
1349 /* attbase - aperture base */
1350 pci_write_config_dword(agp_bridge
->dev
, INTEL_ATTBASE
, agp_bridge
->gatt_bus_addr
);
1353 pci_write_config_dword(agp_bridge
->dev
, INTEL_AGPCTRL
, 0x0000);
1356 pci_read_config_word(agp_bridge
->dev
, INTEL_I7505_MCHCFG
, &temp2
);
1357 pci_write_config_word(agp_bridge
->dev
, INTEL_I7505_MCHCFG
, temp2
| (1 << 9));
1362 /* Setup function */
1363 static const struct gatt_mask intel_generic_masks
[] =
1365 {.mask
= 0x00000017, .type
= 0}
1368 static const struct aper_size_info_8 intel_815_sizes
[2] =
1374 static const struct aper_size_info_8 intel_8xx_sizes
[7] =
1377 {128, 32768, 5, 32},
1385 static const struct aper_size_info_16 intel_generic_sizes
[7] =
1388 {128, 32768, 5, 32},
1396 static const struct aper_size_info_8 intel_830mp_sizes
[4] =
1399 {128, 32768, 5, 32},
1404 static const struct agp_bridge_driver intel_generic_driver
= {
1405 .owner
= THIS_MODULE
,
1406 .aperture_sizes
= intel_generic_sizes
,
1407 .size_type
= U16_APER_SIZE
,
1408 .num_aperture_sizes
= 7,
1409 .configure
= intel_configure
,
1410 .fetch_size
= intel_fetch_size
,
1411 .cleanup
= intel_cleanup
,
1412 .tlb_flush
= intel_tlbflush
,
1413 .mask_memory
= agp_generic_mask_memory
,
1414 .masks
= intel_generic_masks
,
1415 .agp_enable
= agp_generic_enable
,
1416 .cache_flush
= global_cache_flush
,
1417 .create_gatt_table
= agp_generic_create_gatt_table
,
1418 .free_gatt_table
= agp_generic_free_gatt_table
,
1419 .insert_memory
= agp_generic_insert_memory
,
1420 .remove_memory
= agp_generic_remove_memory
,
1421 .alloc_by_type
= agp_generic_alloc_by_type
,
1422 .free_by_type
= agp_generic_free_by_type
,
1423 .agp_alloc_page
= agp_generic_alloc_page
,
1424 .agp_destroy_page
= agp_generic_destroy_page
,
1425 .agp_type_to_mask_type
= agp_generic_type_to_mask_type
,
1428 static const struct agp_bridge_driver intel_810_driver
= {
1429 .owner
= THIS_MODULE
,
1430 .aperture_sizes
= intel_i810_sizes
,
1431 .size_type
= FIXED_APER_SIZE
,
1432 .num_aperture_sizes
= 2,
1433 .needs_scratch_page
= TRUE
,
1434 .configure
= intel_i810_configure
,
1435 .fetch_size
= intel_i810_fetch_size
,
1436 .cleanup
= intel_i810_cleanup
,
1437 .tlb_flush
= intel_i810_tlbflush
,
1438 .mask_memory
= intel_i810_mask_memory
,
1439 .masks
= intel_i810_masks
,
1440 .agp_enable
= intel_i810_agp_enable
,
1441 .cache_flush
= global_cache_flush
,
1442 .create_gatt_table
= agp_generic_create_gatt_table
,
1443 .free_gatt_table
= agp_generic_free_gatt_table
,
1444 .insert_memory
= intel_i810_insert_entries
,
1445 .remove_memory
= intel_i810_remove_entries
,
1446 .alloc_by_type
= intel_i810_alloc_by_type
,
1447 .free_by_type
= intel_i810_free_by_type
,
1448 .agp_alloc_page
= agp_generic_alloc_page
,
1449 .agp_destroy_page
= agp_generic_destroy_page
,
1450 .agp_type_to_mask_type
= agp_generic_type_to_mask_type
,
1453 static const struct agp_bridge_driver intel_815_driver
= {
1454 .owner
= THIS_MODULE
,
1455 .aperture_sizes
= intel_815_sizes
,
1456 .size_type
= U8_APER_SIZE
,
1457 .num_aperture_sizes
= 2,
1458 .configure
= intel_815_configure
,
1459 .fetch_size
= intel_815_fetch_size
,
1460 .cleanup
= intel_8xx_cleanup
,
1461 .tlb_flush
= intel_8xx_tlbflush
,
1462 .mask_memory
= agp_generic_mask_memory
,
1463 .masks
= intel_generic_masks
,
1464 .agp_enable
= agp_generic_enable
,
1465 .cache_flush
= global_cache_flush
,
1466 .create_gatt_table
= agp_generic_create_gatt_table
,
1467 .free_gatt_table
= agp_generic_free_gatt_table
,
1468 .insert_memory
= agp_generic_insert_memory
,
1469 .remove_memory
= agp_generic_remove_memory
,
1470 .alloc_by_type
= agp_generic_alloc_by_type
,
1471 .free_by_type
= agp_generic_free_by_type
,
1472 .agp_alloc_page
= agp_generic_alloc_page
,
1473 .agp_destroy_page
= agp_generic_destroy_page
,
1474 .agp_type_to_mask_type
= agp_generic_type_to_mask_type
,
1477 static const struct agp_bridge_driver intel_830_driver
= {
1478 .owner
= THIS_MODULE
,
1479 .aperture_sizes
= intel_i830_sizes
,
1480 .size_type
= FIXED_APER_SIZE
,
1481 .num_aperture_sizes
= 4,
1482 .needs_scratch_page
= TRUE
,
1483 .configure
= intel_i830_configure
,
1484 .fetch_size
= intel_i830_fetch_size
,
1485 .cleanup
= intel_i830_cleanup
,
1486 .tlb_flush
= intel_i810_tlbflush
,
1487 .mask_memory
= intel_i810_mask_memory
,
1488 .masks
= intel_i810_masks
,
1489 .agp_enable
= intel_i810_agp_enable
,
1490 .cache_flush
= global_cache_flush
,
1491 .create_gatt_table
= intel_i830_create_gatt_table
,
1492 .free_gatt_table
= intel_i830_free_gatt_table
,
1493 .insert_memory
= intel_i830_insert_entries
,
1494 .remove_memory
= intel_i830_remove_entries
,
1495 .alloc_by_type
= intel_i830_alloc_by_type
,
1496 .free_by_type
= intel_i810_free_by_type
,
1497 .agp_alloc_page
= agp_generic_alloc_page
,
1498 .agp_destroy_page
= agp_generic_destroy_page
,
1499 .agp_type_to_mask_type
= intel_i830_type_to_mask_type
,
1502 static const struct agp_bridge_driver intel_820_driver
= {
1503 .owner
= THIS_MODULE
,
1504 .aperture_sizes
= intel_8xx_sizes
,
1505 .size_type
= U8_APER_SIZE
,
1506 .num_aperture_sizes
= 7,
1507 .configure
= intel_820_configure
,
1508 .fetch_size
= intel_8xx_fetch_size
,
1509 .cleanup
= intel_820_cleanup
,
1510 .tlb_flush
= intel_820_tlbflush
,
1511 .mask_memory
= agp_generic_mask_memory
,
1512 .masks
= intel_generic_masks
,
1513 .agp_enable
= agp_generic_enable
,
1514 .cache_flush
= global_cache_flush
,
1515 .create_gatt_table
= agp_generic_create_gatt_table
,
1516 .free_gatt_table
= agp_generic_free_gatt_table
,
1517 .insert_memory
= agp_generic_insert_memory
,
1518 .remove_memory
= agp_generic_remove_memory
,
1519 .alloc_by_type
= agp_generic_alloc_by_type
,
1520 .free_by_type
= agp_generic_free_by_type
,
1521 .agp_alloc_page
= agp_generic_alloc_page
,
1522 .agp_destroy_page
= agp_generic_destroy_page
,
1523 .agp_type_to_mask_type
= agp_generic_type_to_mask_type
,
1526 static const struct agp_bridge_driver intel_830mp_driver
= {
1527 .owner
= THIS_MODULE
,
1528 .aperture_sizes
= intel_830mp_sizes
,
1529 .size_type
= U8_APER_SIZE
,
1530 .num_aperture_sizes
= 4,
1531 .configure
= intel_830mp_configure
,
1532 .fetch_size
= intel_8xx_fetch_size
,
1533 .cleanup
= intel_8xx_cleanup
,
1534 .tlb_flush
= intel_8xx_tlbflush
,
1535 .mask_memory
= agp_generic_mask_memory
,
1536 .masks
= intel_generic_masks
,
1537 .agp_enable
= agp_generic_enable
,
1538 .cache_flush
= global_cache_flush
,
1539 .create_gatt_table
= agp_generic_create_gatt_table
,
1540 .free_gatt_table
= agp_generic_free_gatt_table
,
1541 .insert_memory
= agp_generic_insert_memory
,
1542 .remove_memory
= agp_generic_remove_memory
,
1543 .alloc_by_type
= agp_generic_alloc_by_type
,
1544 .free_by_type
= agp_generic_free_by_type
,
1545 .agp_alloc_page
= agp_generic_alloc_page
,
1546 .agp_destroy_page
= agp_generic_destroy_page
,
1547 .agp_type_to_mask_type
= agp_generic_type_to_mask_type
,
1550 static const struct agp_bridge_driver intel_840_driver
= {
1551 .owner
= THIS_MODULE
,
1552 .aperture_sizes
= intel_8xx_sizes
,
1553 .size_type
= U8_APER_SIZE
,
1554 .num_aperture_sizes
= 7,
1555 .configure
= intel_840_configure
,
1556 .fetch_size
= intel_8xx_fetch_size
,
1557 .cleanup
= intel_8xx_cleanup
,
1558 .tlb_flush
= intel_8xx_tlbflush
,
1559 .mask_memory
= agp_generic_mask_memory
,
1560 .masks
= intel_generic_masks
,
1561 .agp_enable
= agp_generic_enable
,
1562 .cache_flush
= global_cache_flush
,
1563 .create_gatt_table
= agp_generic_create_gatt_table
,
1564 .free_gatt_table
= agp_generic_free_gatt_table
,
1565 .insert_memory
= agp_generic_insert_memory
,
1566 .remove_memory
= agp_generic_remove_memory
,
1567 .alloc_by_type
= agp_generic_alloc_by_type
,
1568 .free_by_type
= agp_generic_free_by_type
,
1569 .agp_alloc_page
= agp_generic_alloc_page
,
1570 .agp_destroy_page
= agp_generic_destroy_page
,
1571 .agp_type_to_mask_type
= agp_generic_type_to_mask_type
,
1574 static const struct agp_bridge_driver intel_845_driver
= {
1575 .owner
= THIS_MODULE
,
1576 .aperture_sizes
= intel_8xx_sizes
,
1577 .size_type
= U8_APER_SIZE
,
1578 .num_aperture_sizes
= 7,
1579 .configure
= intel_845_configure
,
1580 .fetch_size
= intel_8xx_fetch_size
,
1581 .cleanup
= intel_8xx_cleanup
,
1582 .tlb_flush
= intel_8xx_tlbflush
,
1583 .mask_memory
= agp_generic_mask_memory
,
1584 .masks
= intel_generic_masks
,
1585 .agp_enable
= agp_generic_enable
,
1586 .cache_flush
= global_cache_flush
,
1587 .create_gatt_table
= agp_generic_create_gatt_table
,
1588 .free_gatt_table
= agp_generic_free_gatt_table
,
1589 .insert_memory
= agp_generic_insert_memory
,
1590 .remove_memory
= agp_generic_remove_memory
,
1591 .alloc_by_type
= agp_generic_alloc_by_type
,
1592 .free_by_type
= agp_generic_free_by_type
,
1593 .agp_alloc_page
= agp_generic_alloc_page
,
1594 .agp_destroy_page
= agp_generic_destroy_page
,
1595 .agp_type_to_mask_type
= agp_generic_type_to_mask_type
,
1598 static const struct agp_bridge_driver intel_850_driver
= {
1599 .owner
= THIS_MODULE
,
1600 .aperture_sizes
= intel_8xx_sizes
,
1601 .size_type
= U8_APER_SIZE
,
1602 .num_aperture_sizes
= 7,
1603 .configure
= intel_850_configure
,
1604 .fetch_size
= intel_8xx_fetch_size
,
1605 .cleanup
= intel_8xx_cleanup
,
1606 .tlb_flush
= intel_8xx_tlbflush
,
1607 .mask_memory
= agp_generic_mask_memory
,
1608 .masks
= intel_generic_masks
,
1609 .agp_enable
= agp_generic_enable
,
1610 .cache_flush
= global_cache_flush
,
1611 .create_gatt_table
= agp_generic_create_gatt_table
,
1612 .free_gatt_table
= agp_generic_free_gatt_table
,
1613 .insert_memory
= agp_generic_insert_memory
,
1614 .remove_memory
= agp_generic_remove_memory
,
1615 .alloc_by_type
= agp_generic_alloc_by_type
,
1616 .free_by_type
= agp_generic_free_by_type
,
1617 .agp_alloc_page
= agp_generic_alloc_page
,
1618 .agp_destroy_page
= agp_generic_destroy_page
,
1619 .agp_type_to_mask_type
= agp_generic_type_to_mask_type
,
1622 static const struct agp_bridge_driver intel_860_driver
= {
1623 .owner
= THIS_MODULE
,
1624 .aperture_sizes
= intel_8xx_sizes
,
1625 .size_type
= U8_APER_SIZE
,
1626 .num_aperture_sizes
= 7,
1627 .configure
= intel_860_configure
,
1628 .fetch_size
= intel_8xx_fetch_size
,
1629 .cleanup
= intel_8xx_cleanup
,
1630 .tlb_flush
= intel_8xx_tlbflush
,
1631 .mask_memory
= agp_generic_mask_memory
,
1632 .masks
= intel_generic_masks
,
1633 .agp_enable
= agp_generic_enable
,
1634 .cache_flush
= global_cache_flush
,
1635 .create_gatt_table
= agp_generic_create_gatt_table
,
1636 .free_gatt_table
= agp_generic_free_gatt_table
,
1637 .insert_memory
= agp_generic_insert_memory
,
1638 .remove_memory
= agp_generic_remove_memory
,
1639 .alloc_by_type
= agp_generic_alloc_by_type
,
1640 .free_by_type
= agp_generic_free_by_type
,
1641 .agp_alloc_page
= agp_generic_alloc_page
,
1642 .agp_destroy_page
= agp_generic_destroy_page
,
1643 .agp_type_to_mask_type
= agp_generic_type_to_mask_type
,
1646 static const struct agp_bridge_driver intel_915_driver
= {
1647 .owner
= THIS_MODULE
,
1648 .aperture_sizes
= intel_i830_sizes
,
1649 .size_type
= FIXED_APER_SIZE
,
1650 .num_aperture_sizes
= 4,
1651 .needs_scratch_page
= TRUE
,
1652 .configure
= intel_i915_configure
,
1653 .fetch_size
= intel_i9xx_fetch_size
,
1654 .cleanup
= intel_i915_cleanup
,
1655 .tlb_flush
= intel_i810_tlbflush
,
1656 .mask_memory
= intel_i810_mask_memory
,
1657 .masks
= intel_i810_masks
,
1658 .agp_enable
= intel_i810_agp_enable
,
1659 .cache_flush
= global_cache_flush
,
1660 .create_gatt_table
= intel_i915_create_gatt_table
,
1661 .free_gatt_table
= intel_i830_free_gatt_table
,
1662 .insert_memory
= intel_i915_insert_entries
,
1663 .remove_memory
= intel_i915_remove_entries
,
1664 .alloc_by_type
= intel_i830_alloc_by_type
,
1665 .free_by_type
= intel_i810_free_by_type
,
1666 .agp_alloc_page
= agp_generic_alloc_page
,
1667 .agp_destroy_page
= agp_generic_destroy_page
,
1668 .agp_type_to_mask_type
= intel_i830_type_to_mask_type
,
1671 static const struct agp_bridge_driver intel_i965_driver
= {
1672 .owner
= THIS_MODULE
,
1673 .aperture_sizes
= intel_i830_sizes
,
1674 .size_type
= FIXED_APER_SIZE
,
1675 .num_aperture_sizes
= 4,
1676 .needs_scratch_page
= TRUE
,
1677 .configure
= intel_i915_configure
,
1678 .fetch_size
= intel_i9xx_fetch_size
,
1679 .cleanup
= intel_i915_cleanup
,
1680 .tlb_flush
= intel_i810_tlbflush
,
1681 .mask_memory
= intel_i965_mask_memory
,
1682 .masks
= intel_i810_masks
,
1683 .agp_enable
= intel_i810_agp_enable
,
1684 .cache_flush
= global_cache_flush
,
1685 .create_gatt_table
= intel_i965_create_gatt_table
,
1686 .free_gatt_table
= intel_i830_free_gatt_table
,
1687 .insert_memory
= intel_i915_insert_entries
,
1688 .remove_memory
= intel_i915_remove_entries
,
1689 .alloc_by_type
= intel_i830_alloc_by_type
,
1690 .free_by_type
= intel_i810_free_by_type
,
1691 .agp_alloc_page
= agp_generic_alloc_page
,
1692 .agp_destroy_page
= agp_generic_destroy_page
,
1693 .agp_type_to_mask_type
= intel_i830_type_to_mask_type
,
1696 static const struct agp_bridge_driver intel_7505_driver
= {
1697 .owner
= THIS_MODULE
,
1698 .aperture_sizes
= intel_8xx_sizes
,
1699 .size_type
= U8_APER_SIZE
,
1700 .num_aperture_sizes
= 7,
1701 .configure
= intel_7505_configure
,
1702 .fetch_size
= intel_8xx_fetch_size
,
1703 .cleanup
= intel_8xx_cleanup
,
1704 .tlb_flush
= intel_8xx_tlbflush
,
1705 .mask_memory
= agp_generic_mask_memory
,
1706 .masks
= intel_generic_masks
,
1707 .agp_enable
= agp_generic_enable
,
1708 .cache_flush
= global_cache_flush
,
1709 .create_gatt_table
= agp_generic_create_gatt_table
,
1710 .free_gatt_table
= agp_generic_free_gatt_table
,
1711 .insert_memory
= agp_generic_insert_memory
,
1712 .remove_memory
= agp_generic_remove_memory
,
1713 .alloc_by_type
= agp_generic_alloc_by_type
,
1714 .free_by_type
= agp_generic_free_by_type
,
1715 .agp_alloc_page
= agp_generic_alloc_page
,
1716 .agp_destroy_page
= agp_generic_destroy_page
,
1717 .agp_type_to_mask_type
= agp_generic_type_to_mask_type
,
1721 static int find_gmch(u16 device
)
1723 struct pci_dev
*gmch_device
;
1725 gmch_device
= pci_get_device(PCI_VENDOR_ID_INTEL
, device
, NULL
);
1726 if (gmch_device
&& PCI_FUNC(gmch_device
->devfn
) != 0) {
1727 gmch_device
= pci_get_device(PCI_VENDOR_ID_INTEL
,
1728 device
, gmch_device
);
1734 intel_private
.pcidev
= gmch_device
;
1738 /* Table to describe Intel GMCH and AGP/PCIE GART drivers. At least one of
1739 * driver and gmch_driver must be non-null, and find_gmch will determine
1740 * which one should be used if a gmch_chip_id is present.
1742 static const struct intel_driver_description
{
1743 unsigned int chip_id
;
1744 unsigned int gmch_chip_id
;
1746 const struct agp_bridge_driver
*driver
;
1747 const struct agp_bridge_driver
*gmch_driver
;
1748 } intel_agp_chipsets
[] = {
1749 { PCI_DEVICE_ID_INTEL_82443LX_0
, 0, "440LX", &intel_generic_driver
, NULL
},
1750 { PCI_DEVICE_ID_INTEL_82443BX_0
, 0, "440BX", &intel_generic_driver
, NULL
},
1751 { PCI_DEVICE_ID_INTEL_82443GX_0
, 0, "440GX", &intel_generic_driver
, NULL
},
1752 { PCI_DEVICE_ID_INTEL_82810_MC1
, PCI_DEVICE_ID_INTEL_82810_IG1
, "i810",
1753 NULL
, &intel_810_driver
},
1754 { PCI_DEVICE_ID_INTEL_82810_MC3
, PCI_DEVICE_ID_INTEL_82810_IG3
, "i810",
1755 NULL
, &intel_810_driver
},
1756 { PCI_DEVICE_ID_INTEL_82810E_MC
, PCI_DEVICE_ID_INTEL_82810E_IG
, "i810",
1757 NULL
, &intel_810_driver
},
1758 { PCI_DEVICE_ID_INTEL_82815_MC
, PCI_DEVICE_ID_INTEL_82815_CGC
, "i815",
1759 &intel_810_driver
, &intel_815_driver
},
1760 { PCI_DEVICE_ID_INTEL_82820_HB
, 0, "i820", &intel_820_driver
, NULL
},
1761 { PCI_DEVICE_ID_INTEL_82820_UP_HB
, 0, "i820", &intel_820_driver
, NULL
},
1762 { PCI_DEVICE_ID_INTEL_82830_HB
, PCI_DEVICE_ID_INTEL_82830_CGC
, "830M",
1763 &intel_830mp_driver
, &intel_830_driver
},
1764 { PCI_DEVICE_ID_INTEL_82840_HB
, 0, "i840", &intel_840_driver
, NULL
},
1765 { PCI_DEVICE_ID_INTEL_82845_HB
, 0, "845G", &intel_845_driver
, NULL
},
1766 { PCI_DEVICE_ID_INTEL_82845G_HB
, PCI_DEVICE_ID_INTEL_82845G_IG
, "830M",
1767 &intel_845_driver
, &intel_830_driver
},
1768 { PCI_DEVICE_ID_INTEL_82850_HB
, 0, "i850", &intel_850_driver
, NULL
},
1769 { PCI_DEVICE_ID_INTEL_82855PM_HB
, 0, "855PM", &intel_845_driver
, NULL
},
1770 { PCI_DEVICE_ID_INTEL_82855GM_HB
, PCI_DEVICE_ID_INTEL_82855GM_IG
, "855GM",
1771 &intel_845_driver
, &intel_830_driver
},
1772 { PCI_DEVICE_ID_INTEL_82860_HB
, 0, "i860", &intel_860_driver
, NULL
},
1773 { PCI_DEVICE_ID_INTEL_82865_HB
, PCI_DEVICE_ID_INTEL_82865_IG
, "865",
1774 &intel_845_driver
, &intel_830_driver
},
1775 { PCI_DEVICE_ID_INTEL_82875_HB
, 0, "i875", &intel_845_driver
, NULL
},
1776 { PCI_DEVICE_ID_INTEL_82915G_HB
, PCI_DEVICE_ID_INTEL_82915G_IG
, "915G",
1777 &intel_845_driver
, &intel_915_driver
},
1778 { PCI_DEVICE_ID_INTEL_82915GM_HB
, PCI_DEVICE_ID_INTEL_82915GM_IG
, "915GM",
1779 &intel_845_driver
, &intel_915_driver
},
1780 { PCI_DEVICE_ID_INTEL_82945G_HB
, PCI_DEVICE_ID_INTEL_82945G_IG
, "945G",
1781 &intel_845_driver
, &intel_915_driver
},
1782 { PCI_DEVICE_ID_INTEL_82945GM_HB
, PCI_DEVICE_ID_INTEL_82945GM_IG
, "945GM",
1783 &intel_845_driver
, &intel_915_driver
},
1784 { PCI_DEVICE_ID_INTEL_82946GZ_HB
, PCI_DEVICE_ID_INTEL_82946GZ_IG
, "946GZ",
1785 &intel_845_driver
, &intel_i965_driver
},
1786 { PCI_DEVICE_ID_INTEL_82965G_1_HB
, PCI_DEVICE_ID_INTEL_82965G_1_IG
, "965G",
1787 &intel_845_driver
, &intel_i965_driver
},
1788 { PCI_DEVICE_ID_INTEL_82965Q_HB
, PCI_DEVICE_ID_INTEL_82965Q_IG
, "965Q",
1789 &intel_845_driver
, &intel_i965_driver
},
1790 { PCI_DEVICE_ID_INTEL_82965G_HB
, PCI_DEVICE_ID_INTEL_82965G_IG
, "965G",
1791 &intel_845_driver
, &intel_i965_driver
},
1792 { PCI_DEVICE_ID_INTEL_82965GM_HB
, PCI_DEVICE_ID_INTEL_82965GM_IG
, "965GM",
1793 &intel_845_driver
, &intel_i965_driver
},
1794 { PCI_DEVICE_ID_INTEL_7505_0
, 0, "E7505", &intel_7505_driver
, NULL
},
1795 { PCI_DEVICE_ID_INTEL_7205_0
, 0, "E7205", &intel_7505_driver
, NULL
},
1796 { 0, 0, NULL
, NULL
, NULL
}
1799 static int __devinit
agp_intel_probe(struct pci_dev
*pdev
,
1800 const struct pci_device_id
*ent
)
1802 struct agp_bridge_data
*bridge
;
1807 cap_ptr
= pci_find_capability(pdev
, PCI_CAP_ID_AGP
);
1809 bridge
= agp_alloc_bridge();
1813 for (i
= 0; intel_agp_chipsets
[i
].name
!= NULL
; i
++) {
1814 /* In case that multiple models of gfx chip may
1815 stand on same host bridge type, this can be
1816 sure we detect the right IGD. */
1817 if ((pdev
->device
== intel_agp_chipsets
[i
].chip_id
) &&
1818 ((intel_agp_chipsets
[i
].gmch_chip_id
== 0) ||
1819 find_gmch(intel_agp_chipsets
[i
].gmch_chip_id
)))
1823 if (intel_agp_chipsets
[i
].name
== NULL
) {
1825 printk(KERN_WARNING PFX
"Unsupported Intel chipset"
1826 "(device id: %04x)\n", pdev
->device
);
1827 agp_put_bridge(bridge
);
1831 if (intel_agp_chipsets
[i
].gmch_chip_id
!= 0)
1832 bridge
->driver
= intel_agp_chipsets
[i
].gmch_driver
;
1834 bridge
->driver
= intel_agp_chipsets
[i
].driver
;
1836 if (bridge
->driver
== NULL
) {
1837 printk(KERN_WARNING PFX
"Failed to find bridge device "
1838 "(chip_id: %04x)\n", intel_agp_chipsets
[i
].gmch_chip_id
);
1839 agp_put_bridge(bridge
);
1844 bridge
->capndx
= cap_ptr
;
1845 bridge
->dev_private_data
= &intel_private
;
1847 printk(KERN_INFO PFX
"Detected an Intel %s Chipset.\n",
1848 intel_agp_chipsets
[i
].name
);
1851 * The following fixes the case where the BIOS has "forgotten" to
1852 * provide an address range for the GART.
1853 * 20030610 - hamish@zot.org
1855 r
= &pdev
->resource
[0];
1856 if (!r
->start
&& r
->end
) {
1857 if (pci_assign_resource(pdev
, 0)) {
1858 printk(KERN_ERR PFX
"could not assign resource 0\n");
1859 agp_put_bridge(bridge
);
1865 * If the device has not been properly setup, the following will catch
1866 * the problem and should stop the system from crashing.
1867 * 20030610 - hamish@zot.org
1869 if (pci_enable_device(pdev
)) {
1870 printk(KERN_ERR PFX
"Unable to Enable PCI device\n");
1871 agp_put_bridge(bridge
);
1875 /* Fill in the mode register */
1877 pci_read_config_dword(pdev
,
1878 bridge
->capndx
+PCI_AGP_STATUS
,
1882 pci_set_drvdata(pdev
, bridge
);
1883 return agp_add_bridge(bridge
);
1886 static void __devexit
agp_intel_remove(struct pci_dev
*pdev
)
1888 struct agp_bridge_data
*bridge
= pci_get_drvdata(pdev
);
1890 agp_remove_bridge(bridge
);
1892 if (intel_private
.pcidev
)
1893 pci_dev_put(intel_private
.pcidev
);
1895 agp_put_bridge(bridge
);
1899 static int agp_intel_resume(struct pci_dev
*pdev
)
1901 struct agp_bridge_data
*bridge
= pci_get_drvdata(pdev
);
1903 pci_restore_state(pdev
);
1905 /* We should restore our graphics device's config space,
1906 * as host bridge (00:00) resumes before graphics device (02:00),
1907 * then our access to its pci space can work right.
1909 if (intel_private
.pcidev
)
1910 pci_restore_state(intel_private
.pcidev
);
1912 if (bridge
->driver
== &intel_generic_driver
)
1914 else if (bridge
->driver
== &intel_850_driver
)
1915 intel_850_configure();
1916 else if (bridge
->driver
== &intel_845_driver
)
1917 intel_845_configure();
1918 else if (bridge
->driver
== &intel_830mp_driver
)
1919 intel_830mp_configure();
1920 else if (bridge
->driver
== &intel_915_driver
)
1921 intel_i915_configure();
1922 else if (bridge
->driver
== &intel_830_driver
)
1923 intel_i830_configure();
1924 else if (bridge
->driver
== &intel_810_driver
)
1925 intel_i810_configure();
1926 else if (bridge
->driver
== &intel_i965_driver
)
1927 intel_i915_configure();
1933 static struct pci_device_id agp_intel_pci_table
[] = {
1936 .class = (PCI_CLASS_BRIDGE_HOST << 8), \
1938 .vendor = PCI_VENDOR_ID_INTEL, \
1940 .subvendor = PCI_ANY_ID, \
1941 .subdevice = PCI_ANY_ID, \
1943 ID(PCI_DEVICE_ID_INTEL_82443LX_0
),
1944 ID(PCI_DEVICE_ID_INTEL_82443BX_0
),
1945 ID(PCI_DEVICE_ID_INTEL_82443GX_0
),
1946 ID(PCI_DEVICE_ID_INTEL_82810_MC1
),
1947 ID(PCI_DEVICE_ID_INTEL_82810_MC3
),
1948 ID(PCI_DEVICE_ID_INTEL_82810E_MC
),
1949 ID(PCI_DEVICE_ID_INTEL_82815_MC
),
1950 ID(PCI_DEVICE_ID_INTEL_82820_HB
),
1951 ID(PCI_DEVICE_ID_INTEL_82820_UP_HB
),
1952 ID(PCI_DEVICE_ID_INTEL_82830_HB
),
1953 ID(PCI_DEVICE_ID_INTEL_82840_HB
),
1954 ID(PCI_DEVICE_ID_INTEL_82845_HB
),
1955 ID(PCI_DEVICE_ID_INTEL_82845G_HB
),
1956 ID(PCI_DEVICE_ID_INTEL_82850_HB
),
1957 ID(PCI_DEVICE_ID_INTEL_82855PM_HB
),
1958 ID(PCI_DEVICE_ID_INTEL_82855GM_HB
),
1959 ID(PCI_DEVICE_ID_INTEL_82860_HB
),
1960 ID(PCI_DEVICE_ID_INTEL_82865_HB
),
1961 ID(PCI_DEVICE_ID_INTEL_82875_HB
),
1962 ID(PCI_DEVICE_ID_INTEL_7505_0
),
1963 ID(PCI_DEVICE_ID_INTEL_7205_0
),
1964 ID(PCI_DEVICE_ID_INTEL_82915G_HB
),
1965 ID(PCI_DEVICE_ID_INTEL_82915GM_HB
),
1966 ID(PCI_DEVICE_ID_INTEL_82945G_HB
),
1967 ID(PCI_DEVICE_ID_INTEL_82945GM_HB
),
1968 ID(PCI_DEVICE_ID_INTEL_82946GZ_HB
),
1969 ID(PCI_DEVICE_ID_INTEL_82965G_1_HB
),
1970 ID(PCI_DEVICE_ID_INTEL_82965Q_HB
),
1971 ID(PCI_DEVICE_ID_INTEL_82965G_HB
),
1972 ID(PCI_DEVICE_ID_INTEL_82965GM_HB
),
1976 MODULE_DEVICE_TABLE(pci
, agp_intel_pci_table
);
1978 static struct pci_driver agp_intel_pci_driver
= {
1979 .name
= "agpgart-intel",
1980 .id_table
= agp_intel_pci_table
,
1981 .probe
= agp_intel_probe
,
1982 .remove
= __devexit_p(agp_intel_remove
),
1984 .resume
= agp_intel_resume
,
1988 static int __init
agp_intel_init(void)
1992 return pci_register_driver(&agp_intel_pci_driver
);
1995 static void __exit
agp_intel_cleanup(void)
1997 pci_unregister_driver(&agp_intel_pci_driver
);
2000 module_init(agp_intel_init
);
2001 module_exit(agp_intel_cleanup
);
2003 MODULE_AUTHOR("Dave Jones <davej@codemonkey.org.uk>");
2004 MODULE_LICENSE("GPL and additional rights");