2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Intel AGPGART routines.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/init.h>
|
2007-02-06 16:08:28 +00:00
|
|
|
#include <linux/kernel.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/agp_backend.h>
|
|
|
|
#include "agp.h"
|
|
|
|
|
2008-01-24 00:34:09 +00:00
|
|
|
#define PCI_DEVICE_ID_INTEL_E7221_HB 0x2588
|
|
|
|
#define PCI_DEVICE_ID_INTEL_E7221_IG 0x258a
|
2006-09-06 15:57:18 +00:00
|
|
|
#define PCI_DEVICE_ID_INTEL_82946GZ_HB 0x2970
|
|
|
|
#define PCI_DEVICE_ID_INTEL_82946GZ_IG 0x2972
|
2008-01-23 05:49:26 +00:00
|
|
|
#define PCI_DEVICE_ID_INTEL_82G35_HB 0x2980
|
|
|
|
#define PCI_DEVICE_ID_INTEL_82G35_IG 0x2982
|
2006-09-06 15:57:18 +00:00
|
|
|
#define PCI_DEVICE_ID_INTEL_82965Q_HB 0x2990
|
|
|
|
#define PCI_DEVICE_ID_INTEL_82965Q_IG 0x2992
|
|
|
|
#define PCI_DEVICE_ID_INTEL_82965G_HB 0x29A0
|
|
|
|
#define PCI_DEVICE_ID_INTEL_82965G_IG 0x29A2
|
2007-04-09 00:51:36 +00:00
|
|
|
#define PCI_DEVICE_ID_INTEL_82965GM_HB 0x2A00
|
|
|
|
#define PCI_DEVICE_ID_INTEL_82965GM_IG 0x2A02
|
2007-07-26 01:18:09 +00:00
|
|
|
#define PCI_DEVICE_ID_INTEL_82965GME_HB 0x2A10
|
2007-05-31 03:34:06 +00:00
|
|
|
#define PCI_DEVICE_ID_INTEL_82965GME_IG 0x2A12
|
2007-07-26 01:18:09 +00:00
|
|
|
#define PCI_DEVICE_ID_INTEL_82945GME_HB 0x27AC
|
2007-05-31 03:51:12 +00:00
|
|
|
#define PCI_DEVICE_ID_INTEL_82945GME_IG 0x27AE
|
2007-06-06 03:16:25 +00:00
|
|
|
#define PCI_DEVICE_ID_INTEL_G33_HB 0x29C0
|
|
|
|
#define PCI_DEVICE_ID_INTEL_G33_IG 0x29C2
|
|
|
|
#define PCI_DEVICE_ID_INTEL_Q35_HB 0x29B0
|
|
|
|
#define PCI_DEVICE_ID_INTEL_Q35_IG 0x29B2
|
|
|
|
#define PCI_DEVICE_ID_INTEL_Q33_HB 0x29D0
|
|
|
|
#define PCI_DEVICE_ID_INTEL_Q33_IG 0x29D2
|
2008-07-30 19:26:50 +00:00
|
|
|
#define PCI_DEVICE_ID_INTEL_GM45_HB 0x2A40
|
|
|
|
#define PCI_DEVICE_ID_INTEL_GM45_IG 0x2A42
|
2008-06-19 04:17:58 +00:00
|
|
|
#define PCI_DEVICE_ID_INTEL_IGD_E_HB 0x2E00
|
|
|
|
#define PCI_DEVICE_ID_INTEL_IGD_E_IG 0x2E02
|
|
|
|
#define PCI_DEVICE_ID_INTEL_Q45_HB 0x2E10
|
|
|
|
#define PCI_DEVICE_ID_INTEL_Q45_IG 0x2E12
|
|
|
|
#define PCI_DEVICE_ID_INTEL_G45_HB 0x2E20
|
|
|
|
#define PCI_DEVICE_ID_INTEL_G45_IG 0x2E22
|
2008-11-17 06:39:00 +00:00
|
|
|
#define PCI_DEVICE_ID_INTEL_G41_HB 0x2E30
|
|
|
|
#define PCI_DEVICE_ID_INTEL_G41_IG 0x2E32
|
2006-09-06 15:57:18 +00:00
|
|
|
|
2008-01-25 01:23:04 +00:00
|
|
|
/* cover 915 and 945 variants */
|
|
|
|
#define IS_I915 (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_E7221_HB || \
|
|
|
|
agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915G_HB || \
|
|
|
|
agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915GM_HB || \
|
|
|
|
agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945G_HB || \
|
|
|
|
agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945GM_HB || \
|
|
|
|
agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945GME_HB)
|
|
|
|
|
2006-09-06 15:57:18 +00:00
|
|
|
#define IS_I965 (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82946GZ_HB || \
|
2008-01-25 01:23:04 +00:00
|
|
|
agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82G35_HB || \
|
|
|
|
agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82965Q_HB || \
|
|
|
|
agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82965G_HB || \
|
|
|
|
agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82965GM_HB || \
|
2008-10-14 18:28:58 +00:00
|
|
|
agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82965GME_HB)
|
2006-09-06 15:57:18 +00:00
|
|
|
|
2007-06-06 03:16:25 +00:00
|
|
|
#define IS_G33 (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_G33_HB || \
|
|
|
|
agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_Q35_HB || \
|
|
|
|
agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_Q33_HB)
|
2006-09-06 15:57:18 +00:00
|
|
|
|
2008-06-19 04:17:58 +00:00
|
|
|
#define IS_G4X (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_IGD_E_HB || \
|
|
|
|
agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_Q45_HB || \
|
2008-10-14 18:28:58 +00:00
|
|
|
agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_G45_HB || \
|
2008-11-17 06:39:00 +00:00
|
|
|
agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_GM45_HB || \
|
|
|
|
agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_G41_HB)
|
2008-06-19 04:17:58 +00:00
|
|
|
|
2007-01-23 09:33:43 +00:00
|
|
|
extern int agp_memory_reserved;
|
|
|
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Intel 815 register */
|
|
|
|
#define INTEL_815_APCONT 0x51
|
|
|
|
#define INTEL_815_ATTBASE_MASK ~0x1FFFFFFF
|
|
|
|
|
|
|
|
/* Intel i820 registers */
|
|
|
|
#define INTEL_I820_RDCR 0x51
|
|
|
|
#define INTEL_I820_ERRSTS 0xc8
|
|
|
|
|
|
|
|
/* Intel i840 registers */
|
|
|
|
#define INTEL_I840_MCHCFG 0x50
|
|
|
|
#define INTEL_I840_ERRSTS 0xc8
|
|
|
|
|
|
|
|
/* Intel i850 registers */
|
|
|
|
#define INTEL_I850_MCHCFG 0x50
|
|
|
|
#define INTEL_I850_ERRSTS 0xc8
|
|
|
|
|
|
|
|
/* intel 915G registers */
|
|
|
|
#define I915_GMADDR 0x18
|
|
|
|
#define I915_MMADDR 0x10
|
|
|
|
#define I915_PTEADDR 0x1C
|
|
|
|
#define I915_GMCH_GMS_STOLEN_48M (0x6 << 4)
|
|
|
|
#define I915_GMCH_GMS_STOLEN_64M (0x7 << 4)
|
2008-06-19 04:17:58 +00:00
|
|
|
#define G33_GMCH_GMS_STOLEN_128M (0x8 << 4)
|
|
|
|
#define G33_GMCH_GMS_STOLEN_256M (0x9 << 4)
|
|
|
|
#define INTEL_GMCH_GMS_STOLEN_96M (0xa << 4)
|
|
|
|
#define INTEL_GMCH_GMS_STOLEN_160M (0xb << 4)
|
|
|
|
#define INTEL_GMCH_GMS_STOLEN_224M (0xc << 4)
|
|
|
|
#define INTEL_GMCH_GMS_STOLEN_352M (0xd << 4)
|
|
|
|
|
2007-10-29 08:06:10 +00:00
|
|
|
#define I915_IFPADDR 0x60
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-09-06 15:57:18 +00:00
|
|
|
/* Intel 965G registers */
|
|
|
|
#define I965_MSAC 0x62
|
2007-10-29 08:06:10 +00:00
|
|
|
#define I965_IFPADDR 0x70
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Intel 7505 registers */
|
|
|
|
#define INTEL_I7505_APSIZE 0x74
|
|
|
|
#define INTEL_I7505_NCAPID 0x60
|
|
|
|
#define INTEL_I7505_NISTAT 0x6c
|
|
|
|
#define INTEL_I7505_ATTBASE 0x78
|
|
|
|
#define INTEL_I7505_ERRSTS 0x42
|
|
|
|
#define INTEL_I7505_AGPCTRL 0x70
|
|
|
|
#define INTEL_I7505_MCHCFG 0x50
|
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct aper_size_info_fixed intel_i810_sizes[] =
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
{64, 16384, 4},
|
|
|
|
/* The 32M mode still requires a 64k gatt */
|
|
|
|
{32, 8192, 4}
|
|
|
|
};
|
|
|
|
|
|
|
|
#define AGP_DCACHE_MEMORY 1
|
|
|
|
#define AGP_PHYS_MEMORY 2
|
2007-01-23 09:33:43 +00:00
|
|
|
#define INTEL_AGP_CACHED_MEMORY 3
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static struct gatt_mask intel_i810_masks[] =
|
|
|
|
{
|
|
|
|
{.mask = I810_PTE_VALID, .type = 0},
|
|
|
|
{.mask = (I810_PTE_VALID | I810_PTE_LOCAL), .type = AGP_DCACHE_MEMORY},
|
2007-01-23 09:33:43 +00:00
|
|
|
{.mask = I810_PTE_VALID, .type = 0},
|
|
|
|
{.mask = I810_PTE_VALID | I830_PTE_SYSTEM_CACHED,
|
|
|
|
.type = INTEL_AGP_CACHED_MEMORY}
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
static struct _intel_private {
|
|
|
|
struct pci_dev *pcidev; /* device one */
|
|
|
|
u8 __iomem *registers;
|
|
|
|
u32 __iomem *gtt; /* I915G */
|
2005-04-16 22:20:36 +00:00
|
|
|
int num_dcache_entries;
|
2007-05-30 01:40:46 +00:00
|
|
|
/* gtt_entries is the number of gtt entries that are already mapped
|
|
|
|
* to stolen memory. Stolen memory is larger than the memory mapped
|
|
|
|
* through gtt_entries, as it includes some reserved space for the BIOS
|
|
|
|
* popup and for the GTT.
|
|
|
|
*/
|
|
|
|
int gtt_entries; /* i830+ */
|
2007-11-21 06:36:31 +00:00
|
|
|
union {
|
|
|
|
void __iomem *i9xx_flush_page;
|
|
|
|
void *i8xx_flush_page;
|
|
|
|
};
|
|
|
|
struct page *i8xx_page;
|
2007-10-29 08:06:10 +00:00
|
|
|
struct resource ifp_resource;
|
2008-01-23 05:34:29 +00:00
|
|
|
int resource_valid;
|
2007-05-30 01:40:46 +00:00
|
|
|
} intel_private;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static int intel_i810_fetch_size(void)
|
|
|
|
{
|
|
|
|
u32 smram_miscc;
|
|
|
|
struct aper_size_info_fixed *values;
|
|
|
|
|
|
|
|
pci_read_config_dword(agp_bridge->dev, I810_SMRAM_MISCC, &smram_miscc);
|
|
|
|
values = A_SIZE_FIX(agp_bridge->driver->aperture_sizes);
|
|
|
|
|
|
|
|
if ((smram_miscc & I810_GMS) == I810_GMS_DISABLE) {
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_warn(&agp_bridge->dev->dev, "i810 is disabled\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if ((smram_miscc & I810_GFX_MEM_WIN_SIZE) == I810_GFX_MEM_WIN_32M) {
|
|
|
|
agp_bridge->previous_size =
|
|
|
|
agp_bridge->current_size = (void *) (values + 1);
|
|
|
|
agp_bridge->aperture_size_idx = 1;
|
|
|
|
return values[1].size;
|
|
|
|
} else {
|
|
|
|
agp_bridge->previous_size =
|
|
|
|
agp_bridge->current_size = (void *) (values);
|
|
|
|
agp_bridge->aperture_size_idx = 0;
|
|
|
|
return values[0].size;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int intel_i810_configure(void)
|
|
|
|
{
|
|
|
|
struct aper_size_info_fixed *current_size;
|
|
|
|
u32 temp;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
current_size = A_SIZE_FIX(agp_bridge->current_size);
|
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
if (!intel_private.registers) {
|
|
|
|
pci_read_config_dword(intel_private.pcidev, I810_MMADDR, &temp);
|
2007-02-04 22:37:42 +00:00
|
|
|
temp &= 0xfff80000;
|
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
intel_private.registers = ioremap(temp, 128 * 4096);
|
|
|
|
if (!intel_private.registers) {
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_err(&intel_private.pcidev->dev,
|
|
|
|
"can't remap memory\n");
|
2007-02-04 22:37:42 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
if ((readl(intel_private.registers+I810_DRAM_CTL)
|
2005-04-16 22:20:36 +00:00
|
|
|
& I810_DRAM_ROW_0) == I810_DRAM_ROW_0_SDRAM) {
|
|
|
|
/* This will need to be dynamically assigned */
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_info(&intel_private.pcidev->dev,
|
|
|
|
"detected 4MB dedicated video ram\n");
|
2007-05-30 01:40:46 +00:00
|
|
|
intel_private.num_dcache_entries = 1024;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-05-30 01:40:46 +00:00
|
|
|
pci_read_config_dword(intel_private.pcidev, I810_GMADDR, &temp);
|
2005-04-16 22:20:36 +00:00
|
|
|
agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
|
2007-05-30 01:40:46 +00:00
|
|
|
writel(agp_bridge->gatt_bus_addr | I810_PGETBL_ENABLED, intel_private.registers+I810_PGETBL_CTL);
|
|
|
|
readl(intel_private.registers+I810_PGETBL_CTL); /* PCI Posting. */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (agp_bridge->driver->needs_scratch_page) {
|
|
|
|
for (i = 0; i < current_size->num_entries; i++) {
|
2007-05-30 01:40:46 +00:00
|
|
|
writel(agp_bridge->scratch_page, intel_private.registers+I810_PTE_BASE+(i*4));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-10-15 00:18:45 +00:00
|
|
|
readl(intel_private.registers+I810_PTE_BASE+((i-1)*4)); /* PCI posting. */
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
global_cache_flush();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_i810_cleanup(void)
|
|
|
|
{
|
2007-05-30 01:40:46 +00:00
|
|
|
writel(0, intel_private.registers+I810_PGETBL_CTL);
|
|
|
|
readl(intel_private.registers); /* PCI Posting. */
|
|
|
|
iounmap(intel_private.registers);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_i810_tlbflush(struct agp_memory *mem)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_i810_agp_enable(struct agp_bridge_data *bridge, u32 mode)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Exists to support ARGB cursors */
|
|
|
|
static void *i8xx_alloc_pages(void)
|
|
|
|
{
|
2008-01-25 01:23:04 +00:00
|
|
|
struct page *page;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
[AGP] Allocate AGP pages with GFP_DMA32 by default
Not all graphic page remappers support physical addresses over the 4GB
mark for remapping, so while some do (the AMD64 GART always did, and I
just fixed the i965 to do so properly), we're safest off just forcing
GFP_DMA32 allocations to make sure graphics pages get allocated in the
low 32-bit address space by default.
AGP sub-drivers that really care, and can do better, could just choose
to implement their own allocator (or we could add another "64-bit safe"
default allocator for their use), but quite frankly, you're not likely
to care in practice.
So for now, this trivial change means that we won't be allocating pages
that we can't map correctly by mistake on x86-64.
[ On traditional 32-bit x86, this could never happen, because GFP_KERNEL
would never allocate any highmem memory anyway ]
Acked-by: Andi Kleen <ak@suse.de>
Acked-by: Dave Jones <davej@redhat.com>
Cc: Eric Anholt <eric@anholt.net>
Cc: Keith Packard <keithp@keithp.com>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-11-22 22:55:29 +00:00
|
|
|
page = alloc_pages(GFP_KERNEL | GFP_DMA32, 2);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (page == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2008-01-30 12:34:06 +00:00
|
|
|
if (set_pages_uc(page, 4) < 0) {
|
|
|
|
set_pages_wb(page, 4);
|
2007-04-02 13:50:14 +00:00
|
|
|
__free_pages(page, 2);
|
2005-04-16 22:20:36 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
get_page(page);
|
|
|
|
atomic_inc(&agp_bridge->current_memory_agp);
|
|
|
|
return page_address(page);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void i8xx_destroy_pages(void *addr)
|
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
if (addr == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
page = virt_to_page(addr);
|
2008-01-30 12:34:06 +00:00
|
|
|
set_pages_wb(page, 4);
|
2005-04-16 22:20:36 +00:00
|
|
|
put_page(page);
|
2007-04-02 13:50:14 +00:00
|
|
|
__free_pages(page, 2);
|
2005-04-16 22:20:36 +00:00
|
|
|
atomic_dec(&agp_bridge->current_memory_agp);
|
|
|
|
}
|
|
|
|
|
2007-01-23 09:33:43 +00:00
|
|
|
static int intel_i830_type_to_mask_type(struct agp_bridge_data *bridge,
|
|
|
|
int type)
|
|
|
|
{
|
|
|
|
if (type < AGP_USER_TYPES)
|
|
|
|
return type;
|
|
|
|
else if (type == AGP_USER_CACHED_MEMORY)
|
|
|
|
return INTEL_AGP_CACHED_MEMORY;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int intel_i810_insert_entries(struct agp_memory *mem, off_t pg_start,
|
|
|
|
int type)
|
|
|
|
{
|
|
|
|
int i, j, num_entries;
|
|
|
|
void *temp;
|
2007-01-23 09:33:43 +00:00
|
|
|
int ret = -EINVAL;
|
|
|
|
int mask_type;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-20 15:33:41 +00:00
|
|
|
if (mem->page_count == 0)
|
2007-01-23 09:33:43 +00:00
|
|
|
goto out;
|
2006-12-20 15:33:41 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
temp = agp_bridge->current_size;
|
|
|
|
num_entries = A_SIZE_FIX(temp)->num_entries;
|
|
|
|
|
2006-02-28 05:54:25 +00:00
|
|
|
if ((pg_start + mem->page_count) > num_entries)
|
2007-01-23 09:33:43 +00:00
|
|
|
goto out_err;
|
2006-02-28 05:54:25 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-01-23 09:33:43 +00:00
|
|
|
for (j = pg_start; j < (pg_start + mem->page_count); j++) {
|
|
|
|
if (!PGE_EMPTY(agp_bridge, readl(agp_bridge->gatt_table+j))) {
|
|
|
|
ret = -EBUSY;
|
|
|
|
goto out_err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-01-23 09:33:43 +00:00
|
|
|
if (type != mem->type)
|
|
|
|
goto out_err;
|
2006-12-20 15:33:41 +00:00
|
|
|
|
2007-01-23 09:33:43 +00:00
|
|
|
mask_type = agp_bridge->driver->agp_type_to_mask_type(agp_bridge, type);
|
|
|
|
|
|
|
|
switch (mask_type) {
|
|
|
|
case AGP_DCACHE_MEMORY:
|
|
|
|
if (!mem->is_flushed)
|
|
|
|
global_cache_flush();
|
|
|
|
for (i = pg_start; i < (pg_start + mem->page_count); i++) {
|
|
|
|
writel((i*4096)|I810_PTE_LOCAL|I810_PTE_VALID,
|
2007-05-30 01:40:46 +00:00
|
|
|
intel_private.registers+I810_PTE_BASE+(i*4));
|
2007-01-23 09:33:43 +00:00
|
|
|
}
|
2007-05-30 01:40:46 +00:00
|
|
|
readl(intel_private.registers+I810_PTE_BASE+((i-1)*4));
|
2007-01-23 09:33:43 +00:00
|
|
|
break;
|
|
|
|
case AGP_PHYS_MEMORY:
|
|
|
|
case AGP_NORMAL_MEMORY:
|
|
|
|
if (!mem->is_flushed)
|
|
|
|
global_cache_flush();
|
|
|
|
for (i = 0, j = pg_start; i < mem->page_count; i++, j++) {
|
|
|
|
writel(agp_bridge->driver->mask_memory(agp_bridge,
|
|
|
|
mem->memory[i],
|
|
|
|
mask_type),
|
2007-05-30 01:40:46 +00:00
|
|
|
intel_private.registers+I810_PTE_BASE+(j*4));
|
2007-01-23 09:33:43 +00:00
|
|
|
}
|
2007-05-30 01:40:46 +00:00
|
|
|
readl(intel_private.registers+I810_PTE_BASE+((j-1)*4));
|
2007-01-23 09:33:43 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto out_err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
agp_bridge->driver->tlb_flush(mem);
|
2007-01-23 09:33:43 +00:00
|
|
|
out:
|
|
|
|
ret = 0;
|
|
|
|
out_err:
|
2008-06-19 00:42:17 +00:00
|
|
|
mem->is_flushed = true;
|
2007-01-23 09:33:43 +00:00
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int intel_i810_remove_entries(struct agp_memory *mem, off_t pg_start,
|
|
|
|
int type)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2006-12-20 15:33:41 +00:00
|
|
|
if (mem->page_count == 0)
|
|
|
|
return 0;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
for (i = pg_start; i < (mem->page_count + pg_start); i++) {
|
2007-05-30 01:40:46 +00:00
|
|
|
writel(agp_bridge->scratch_page, intel_private.registers+I810_PTE_BASE+(i*4));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-05-30 01:40:46 +00:00
|
|
|
readl(intel_private.registers+I810_PTE_BASE+((i-1)*4));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
agp_bridge->driver->tlb_flush(mem);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The i810/i830 requires a physical address to program its mouse
|
|
|
|
* pointer into hardware.
|
|
|
|
* However the Xserver still writes to it through the agp aperture.
|
|
|
|
*/
|
|
|
|
static struct agp_memory *alloc_agpphysmem_i8xx(size_t pg_count, int type)
|
|
|
|
{
|
|
|
|
struct agp_memory *new;
|
|
|
|
void *addr;
|
|
|
|
|
|
|
|
switch (pg_count) {
|
|
|
|
case 1: addr = agp_bridge->driver->agp_alloc_page(agp_bridge);
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
/* kludge to get 4 physical pages for ARGB cursor */
|
|
|
|
addr = i8xx_alloc_pages();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (addr == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
new = agp_create_memory(pg_count);
|
|
|
|
if (new == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2005-03-30 21:17:04 +00:00
|
|
|
new->memory[0] = virt_to_gart(addr);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (pg_count == 4) {
|
|
|
|
/* kludge to get 4 physical pages for ARGB cursor */
|
|
|
|
new->memory[1] = new->memory[0] + PAGE_SIZE;
|
|
|
|
new->memory[2] = new->memory[1] + PAGE_SIZE;
|
|
|
|
new->memory[3] = new->memory[2] + PAGE_SIZE;
|
|
|
|
}
|
|
|
|
new->page_count = pg_count;
|
|
|
|
new->num_scratch_pages = pg_count;
|
|
|
|
new->type = AGP_PHYS_MEMORY;
|
|
|
|
new->physical = new->memory[0];
|
|
|
|
return new;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct agp_memory *intel_i810_alloc_by_type(size_t pg_count, int type)
|
|
|
|
{
|
|
|
|
struct agp_memory *new;
|
|
|
|
|
|
|
|
if (type == AGP_DCACHE_MEMORY) {
|
2007-05-30 01:40:46 +00:00
|
|
|
if (pg_count != intel_private.num_dcache_entries)
|
2005-04-16 22:20:36 +00:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
new = agp_create_memory(1);
|
|
|
|
if (new == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
new->type = AGP_DCACHE_MEMORY;
|
|
|
|
new->page_count = pg_count;
|
|
|
|
new->num_scratch_pages = 0;
|
2007-01-23 09:33:43 +00:00
|
|
|
agp_free_page_array(new);
|
2005-04-16 22:20:36 +00:00
|
|
|
return new;
|
|
|
|
}
|
|
|
|
if (type == AGP_PHYS_MEMORY)
|
|
|
|
return alloc_agpphysmem_i8xx(pg_count, type);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_i810_free_by_type(struct agp_memory *curr)
|
|
|
|
{
|
|
|
|
agp_free_key(curr->key);
|
2006-02-28 05:54:25 +00:00
|
|
|
if (curr->type == AGP_PHYS_MEMORY) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if (curr->page_count == 4)
|
2005-03-30 21:17:04 +00:00
|
|
|
i8xx_destroy_pages(gart_to_virt(curr->memory[0]));
|
2005-11-07 07:35:34 +00:00
|
|
|
else {
|
2008-06-18 08:28:00 +00:00
|
|
|
void *va = gart_to_virt(curr->memory[0]);
|
|
|
|
|
|
|
|
agp_bridge->driver->agp_destroy_page(va,
|
2007-10-15 00:19:16 +00:00
|
|
|
AGP_PAGE_DESTROY_UNMAP);
|
2008-06-18 08:28:00 +00:00
|
|
|
agp_bridge->driver->agp_destroy_page(va,
|
2007-10-15 00:19:16 +00:00
|
|
|
AGP_PAGE_DESTROY_FREE);
|
2005-11-07 07:35:34 +00:00
|
|
|
}
|
2007-01-23 09:33:43 +00:00
|
|
|
agp_free_page_array(curr);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
kfree(curr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned long intel_i810_mask_memory(struct agp_bridge_data *bridge,
|
|
|
|
unsigned long addr, int type)
|
|
|
|
{
|
|
|
|
/* Type checking must be done elsewhere */
|
|
|
|
return addr | bridge->driver->masks[type].mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct aper_size_info_fixed intel_i830_sizes[] =
|
|
|
|
{
|
|
|
|
{128, 32768, 5},
|
|
|
|
/* The 64M mode still requires a 128k gatt */
|
|
|
|
{64, 16384, 5},
|
|
|
|
{256, 65536, 6},
|
2006-09-06 15:57:18 +00:00
|
|
|
{512, 131072, 7},
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static void intel_i830_init_gtt_entries(void)
|
|
|
|
{
|
|
|
|
u16 gmch_ctrl;
|
|
|
|
int gtt_entries;
|
|
|
|
u8 rdct;
|
|
|
|
int local = 0;
|
|
|
|
static const int ddt[4] = { 0, 16, 32, 64 };
|
2006-12-19 20:57:24 +00:00
|
|
|
int size; /* reserved space (in kb) at the top of stolen memory */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-01-25 01:23:04 +00:00
|
|
|
pci_read_config_word(agp_bridge->dev, I830_GMCH_CTRL, &gmch_ctrl);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-19 20:57:24 +00:00
|
|
|
if (IS_I965) {
|
|
|
|
u32 pgetbl_ctl;
|
2007-05-30 01:40:46 +00:00
|
|
|
pgetbl_ctl = readl(intel_private.registers+I810_PGETBL_CTL);
|
2006-12-19 20:57:24 +00:00
|
|
|
|
|
|
|
/* The 965 has a field telling us the size of the GTT,
|
|
|
|
* which may be larger than what is necessary to map the
|
|
|
|
* aperture.
|
|
|
|
*/
|
|
|
|
switch (pgetbl_ctl & I965_PGETBL_SIZE_MASK) {
|
|
|
|
case I965_PGETBL_SIZE_128KB:
|
|
|
|
size = 128;
|
|
|
|
break;
|
|
|
|
case I965_PGETBL_SIZE_256KB:
|
|
|
|
size = 256;
|
|
|
|
break;
|
|
|
|
case I965_PGETBL_SIZE_512KB:
|
|
|
|
size = 512;
|
|
|
|
break;
|
2008-01-23 04:54:37 +00:00
|
|
|
case I965_PGETBL_SIZE_1MB:
|
|
|
|
size = 1024;
|
|
|
|
break;
|
|
|
|
case I965_PGETBL_SIZE_2MB:
|
|
|
|
size = 2048;
|
|
|
|
break;
|
|
|
|
case I965_PGETBL_SIZE_1_5MB:
|
|
|
|
size = 1024 + 512;
|
|
|
|
break;
|
2006-12-19 20:57:24 +00:00
|
|
|
default:
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_info(&intel_private.pcidev->dev,
|
|
|
|
"unknown page table size, assuming 512KB\n");
|
2006-12-19 20:57:24 +00:00
|
|
|
size = 512;
|
|
|
|
}
|
|
|
|
size += 4; /* add in BIOS popup space */
|
2007-06-06 03:16:25 +00:00
|
|
|
} else if (IS_G33) {
|
|
|
|
/* G33's GTT size defined in gmch_ctrl */
|
|
|
|
switch (gmch_ctrl & G33_PGETBL_SIZE_MASK) {
|
|
|
|
case G33_PGETBL_SIZE_1M:
|
|
|
|
size = 1024;
|
|
|
|
break;
|
|
|
|
case G33_PGETBL_SIZE_2M:
|
|
|
|
size = 2048;
|
|
|
|
break;
|
|
|
|
default:
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_info(&agp_bridge->dev->dev,
|
|
|
|
"unknown page table size 0x%x, assuming 512KB\n",
|
2007-06-06 03:16:25 +00:00
|
|
|
(gmch_ctrl & G33_PGETBL_SIZE_MASK));
|
|
|
|
size = 512;
|
|
|
|
}
|
|
|
|
size += 4;
|
2008-06-19 04:17:58 +00:00
|
|
|
} else if (IS_G4X) {
|
|
|
|
/* On 4 series hardware, GTT stolen is separate from graphics
|
2008-10-14 18:28:58 +00:00
|
|
|
* stolen, ignore it in stolen gtt entries counting. However,
|
|
|
|
* 4KB of the stolen memory doesn't get mapped to the GTT.
|
|
|
|
*/
|
|
|
|
size = 4;
|
2006-12-19 20:57:24 +00:00
|
|
|
} else {
|
|
|
|
/* On previous hardware, the GTT size was just what was
|
|
|
|
* required to map the aperture.
|
|
|
|
*/
|
|
|
|
size = agp_bridge->driver->fetch_size() + 4;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82830_HB ||
|
|
|
|
agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82845G_HB) {
|
|
|
|
switch (gmch_ctrl & I830_GMCH_GMS_MASK) {
|
|
|
|
case I830_GMCH_GMS_STOLEN_512:
|
|
|
|
gtt_entries = KB(512) - KB(size);
|
|
|
|
break;
|
|
|
|
case I830_GMCH_GMS_STOLEN_1024:
|
|
|
|
gtt_entries = MB(1) - KB(size);
|
|
|
|
break;
|
|
|
|
case I830_GMCH_GMS_STOLEN_8192:
|
|
|
|
gtt_entries = MB(8) - KB(size);
|
|
|
|
break;
|
|
|
|
case I830_GMCH_GMS_LOCAL:
|
2007-05-30 01:40:46 +00:00
|
|
|
rdct = readb(intel_private.registers+I830_RDRAM_CHANNEL_TYPE);
|
2005-04-16 22:20:36 +00:00
|
|
|
gtt_entries = (I830_RDRAM_ND(rdct) + 1) *
|
|
|
|
MB(ddt[I830_RDRAM_DDT(rdct)]);
|
|
|
|
local = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
gtt_entries = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
2007-09-19 05:46:35 +00:00
|
|
|
switch (gmch_ctrl & I855_GMCH_GMS_MASK) {
|
2005-04-16 22:20:36 +00:00
|
|
|
case I855_GMCH_GMS_STOLEN_1M:
|
|
|
|
gtt_entries = MB(1) - KB(size);
|
|
|
|
break;
|
|
|
|
case I855_GMCH_GMS_STOLEN_4M:
|
|
|
|
gtt_entries = MB(4) - KB(size);
|
|
|
|
break;
|
|
|
|
case I855_GMCH_GMS_STOLEN_8M:
|
|
|
|
gtt_entries = MB(8) - KB(size);
|
|
|
|
break;
|
|
|
|
case I855_GMCH_GMS_STOLEN_16M:
|
|
|
|
gtt_entries = MB(16) - KB(size);
|
|
|
|
break;
|
|
|
|
case I855_GMCH_GMS_STOLEN_32M:
|
|
|
|
gtt_entries = MB(32) - KB(size);
|
|
|
|
break;
|
|
|
|
case I915_GMCH_GMS_STOLEN_48M:
|
|
|
|
/* Check it's really I915G */
|
2008-06-19 04:17:58 +00:00
|
|
|
if (IS_I915 || IS_I965 || IS_G33 || IS_G4X)
|
2005-04-16 22:20:36 +00:00
|
|
|
gtt_entries = MB(48) - KB(size);
|
|
|
|
else
|
|
|
|
gtt_entries = 0;
|
|
|
|
break;
|
|
|
|
case I915_GMCH_GMS_STOLEN_64M:
|
|
|
|
/* Check it's really I915G */
|
2008-06-19 04:17:58 +00:00
|
|
|
if (IS_I915 || IS_I965 || IS_G33 || IS_G4X)
|
2005-04-16 22:20:36 +00:00
|
|
|
gtt_entries = MB(64) - KB(size);
|
|
|
|
else
|
|
|
|
gtt_entries = 0;
|
2007-06-06 03:16:25 +00:00
|
|
|
break;
|
|
|
|
case G33_GMCH_GMS_STOLEN_128M:
|
2008-06-19 04:17:58 +00:00
|
|
|
if (IS_G33 || IS_I965 || IS_G4X)
|
2007-06-06 03:16:25 +00:00
|
|
|
gtt_entries = MB(128) - KB(size);
|
|
|
|
else
|
|
|
|
gtt_entries = 0;
|
|
|
|
break;
|
|
|
|
case G33_GMCH_GMS_STOLEN_256M:
|
2008-06-19 04:17:58 +00:00
|
|
|
if (IS_G33 || IS_I965 || IS_G4X)
|
2007-06-06 03:16:25 +00:00
|
|
|
gtt_entries = MB(256) - KB(size);
|
|
|
|
else
|
|
|
|
gtt_entries = 0;
|
|
|
|
break;
|
2008-06-19 04:17:58 +00:00
|
|
|
case INTEL_GMCH_GMS_STOLEN_96M:
|
|
|
|
if (IS_I965 || IS_G4X)
|
|
|
|
gtt_entries = MB(96) - KB(size);
|
|
|
|
else
|
|
|
|
gtt_entries = 0;
|
|
|
|
break;
|
|
|
|
case INTEL_GMCH_GMS_STOLEN_160M:
|
|
|
|
if (IS_I965 || IS_G4X)
|
|
|
|
gtt_entries = MB(160) - KB(size);
|
|
|
|
else
|
|
|
|
gtt_entries = 0;
|
|
|
|
break;
|
|
|
|
case INTEL_GMCH_GMS_STOLEN_224M:
|
|
|
|
if (IS_I965 || IS_G4X)
|
|
|
|
gtt_entries = MB(224) - KB(size);
|
|
|
|
else
|
|
|
|
gtt_entries = 0;
|
|
|
|
break;
|
|
|
|
case INTEL_GMCH_GMS_STOLEN_352M:
|
|
|
|
if (IS_I965 || IS_G4X)
|
|
|
|
gtt_entries = MB(352) - KB(size);
|
|
|
|
else
|
|
|
|
gtt_entries = 0;
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
default:
|
|
|
|
gtt_entries = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-03-10 19:55:54 +00:00
|
|
|
if (gtt_entries > 0) {
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_info(&agp_bridge->dev->dev, "detected %dK %s memory\n",
|
2005-04-16 22:20:36 +00:00
|
|
|
gtt_entries / KB(1), local ? "local" : "stolen");
|
2009-03-10 19:55:54 +00:00
|
|
|
gtt_entries /= KB(4);
|
|
|
|
} else {
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_info(&agp_bridge->dev->dev,
|
|
|
|
"no pre-allocated video memory detected\n");
|
2009-03-10 19:55:54 +00:00
|
|
|
gtt_entries = 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
intel_private.gtt_entries = gtt_entries;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-11-21 06:36:31 +00:00
|
|
|
static void intel_i830_fini_flush(void)
|
|
|
|
{
|
|
|
|
kunmap(intel_private.i8xx_page);
|
|
|
|
intel_private.i8xx_flush_page = NULL;
|
|
|
|
unmap_page_from_agp(intel_private.i8xx_page);
|
|
|
|
|
|
|
|
__free_page(intel_private.i8xx_page);
|
2008-01-23 05:34:29 +00:00
|
|
|
intel_private.i8xx_page = NULL;
|
2007-11-21 06:36:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_i830_setup_flush(void)
|
|
|
|
{
|
2008-01-23 05:34:29 +00:00
|
|
|
/* return if we've already set the flush mechanism up */
|
|
|
|
if (intel_private.i8xx_page)
|
|
|
|
return;
|
2007-11-21 06:36:31 +00:00
|
|
|
|
|
|
|
intel_private.i8xx_page = alloc_page(GFP_KERNEL | __GFP_ZERO | GFP_DMA32);
|
2008-01-25 01:23:04 +00:00
|
|
|
if (!intel_private.i8xx_page)
|
2007-11-21 06:36:31 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* make page uncached */
|
|
|
|
map_page_into_agp(intel_private.i8xx_page);
|
|
|
|
|
|
|
|
intel_private.i8xx_flush_page = kmap(intel_private.i8xx_page);
|
|
|
|
if (!intel_private.i8xx_flush_page)
|
|
|
|
intel_i830_fini_flush();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_i830_chipset_flush(struct agp_bridge_data *bridge)
|
|
|
|
{
|
|
|
|
unsigned int *pg = intel_private.i8xx_flush_page;
|
|
|
|
int i;
|
|
|
|
|
2008-01-25 01:23:04 +00:00
|
|
|
for (i = 0; i < 256; i += 2)
|
2007-11-21 06:36:31 +00:00
|
|
|
*(pg + i) = i;
|
2008-01-25 01:23:04 +00:00
|
|
|
|
2007-11-21 06:36:31 +00:00
|
|
|
wmb();
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* The intel i830 automatically initializes the agp aperture during POST.
|
|
|
|
* Use the memory already set aside for in the GTT.
|
|
|
|
*/
|
|
|
|
static int intel_i830_create_gatt_table(struct agp_bridge_data *bridge)
|
|
|
|
{
|
|
|
|
int page_order;
|
|
|
|
struct aper_size_info_fixed *size;
|
|
|
|
int num_entries;
|
|
|
|
u32 temp;
|
|
|
|
|
|
|
|
size = agp_bridge->current_size;
|
|
|
|
page_order = size->page_order;
|
|
|
|
num_entries = size->num_entries;
|
|
|
|
agp_bridge->gatt_table_real = NULL;
|
|
|
|
|
2008-01-25 01:23:04 +00:00
|
|
|
pci_read_config_dword(intel_private.pcidev, I810_MMADDR, &temp);
|
2005-04-16 22:20:36 +00:00
|
|
|
temp &= 0xfff80000;
|
|
|
|
|
2008-01-25 01:23:04 +00:00
|
|
|
intel_private.registers = ioremap(temp, 128 * 4096);
|
2007-05-30 01:40:46 +00:00
|
|
|
if (!intel_private.registers)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
temp = readl(intel_private.registers+I810_PGETBL_CTL) & 0xfffff000;
|
2005-04-16 22:20:36 +00:00
|
|
|
global_cache_flush(); /* FIXME: ?? */
|
|
|
|
|
|
|
|
/* we have to call this as early as possible after the MMIO base address is known */
|
|
|
|
intel_i830_init_gtt_entries();
|
|
|
|
|
|
|
|
agp_bridge->gatt_table = NULL;
|
|
|
|
|
|
|
|
agp_bridge->gatt_bus_addr = temp;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return the gatt table to a sane state. Use the top of stolen
|
|
|
|
* memory for the GTT.
|
|
|
|
*/
|
|
|
|
static int intel_i830_free_gatt_table(struct agp_bridge_data *bridge)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int intel_i830_fetch_size(void)
|
|
|
|
{
|
|
|
|
u16 gmch_ctrl;
|
|
|
|
struct aper_size_info_fixed *values;
|
|
|
|
|
|
|
|
values = A_SIZE_FIX(agp_bridge->driver->aperture_sizes);
|
|
|
|
|
|
|
|
if (agp_bridge->dev->device != PCI_DEVICE_ID_INTEL_82830_HB &&
|
|
|
|
agp_bridge->dev->device != PCI_DEVICE_ID_INTEL_82845G_HB) {
|
|
|
|
/* 855GM/852GM/865G has 128MB aperture size */
|
|
|
|
agp_bridge->previous_size = agp_bridge->current_size = (void *) values;
|
|
|
|
agp_bridge->aperture_size_idx = 0;
|
|
|
|
return values[0].size;
|
|
|
|
}
|
|
|
|
|
2008-01-25 01:23:04 +00:00
|
|
|
pci_read_config_word(agp_bridge->dev, I830_GMCH_CTRL, &gmch_ctrl);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if ((gmch_ctrl & I830_GMCH_MEM_MASK) == I830_GMCH_MEM_128M) {
|
|
|
|
agp_bridge->previous_size = agp_bridge->current_size = (void *) values;
|
|
|
|
agp_bridge->aperture_size_idx = 0;
|
|
|
|
return values[0].size;
|
|
|
|
} else {
|
|
|
|
agp_bridge->previous_size = agp_bridge->current_size = (void *) (values + 1);
|
|
|
|
agp_bridge->aperture_size_idx = 1;
|
|
|
|
return values[1].size;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int intel_i830_configure(void)
|
|
|
|
{
|
|
|
|
struct aper_size_info_fixed *current_size;
|
|
|
|
u32 temp;
|
|
|
|
u16 gmch_ctrl;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
current_size = A_SIZE_FIX(agp_bridge->current_size);
|
|
|
|
|
2008-01-25 01:23:04 +00:00
|
|
|
pci_read_config_dword(intel_private.pcidev, I810_GMADDR, &temp);
|
2005-04-16 22:20:36 +00:00
|
|
|
agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
|
|
|
|
|
2008-01-25 01:23:04 +00:00
|
|
|
pci_read_config_word(agp_bridge->dev, I830_GMCH_CTRL, &gmch_ctrl);
|
2005-04-16 22:20:36 +00:00
|
|
|
gmch_ctrl |= I830_GMCH_ENABLED;
|
2008-01-25 01:23:04 +00:00
|
|
|
pci_write_config_word(agp_bridge->dev, I830_GMCH_CTRL, gmch_ctrl);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
writel(agp_bridge->gatt_bus_addr|I810_PGETBL_ENABLED, intel_private.registers+I810_PGETBL_CTL);
|
|
|
|
readl(intel_private.registers+I810_PGETBL_CTL); /* PCI Posting. */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (agp_bridge->driver->needs_scratch_page) {
|
2007-05-30 01:40:46 +00:00
|
|
|
for (i = intel_private.gtt_entries; i < current_size->num_entries; i++) {
|
|
|
|
writel(agp_bridge->scratch_page, intel_private.registers+I810_PTE_BASE+(i*4));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-10-15 00:18:45 +00:00
|
|
|
readl(intel_private.registers+I810_PTE_BASE+((i-1)*4)); /* PCI Posting. */
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
global_cache_flush();
|
2007-11-21 06:36:31 +00:00
|
|
|
|
|
|
|
intel_i830_setup_flush();
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_i830_cleanup(void)
|
|
|
|
{
|
2007-05-30 01:40:46 +00:00
|
|
|
iounmap(intel_private.registers);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-01-25 01:23:04 +00:00
|
|
|
static int intel_i830_insert_entries(struct agp_memory *mem, off_t pg_start,
|
|
|
|
int type)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-01-25 01:23:04 +00:00
|
|
|
int i, j, num_entries;
|
2005-04-16 22:20:36 +00:00
|
|
|
void *temp;
|
2007-01-23 09:33:43 +00:00
|
|
|
int ret = -EINVAL;
|
|
|
|
int mask_type;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-20 15:33:41 +00:00
|
|
|
if (mem->page_count == 0)
|
2007-01-23 09:33:43 +00:00
|
|
|
goto out;
|
2006-12-20 15:33:41 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
temp = agp_bridge->current_size;
|
|
|
|
num_entries = A_SIZE_FIX(temp)->num_entries;
|
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
if (pg_start < intel_private.gtt_entries) {
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_printk(KERN_DEBUG, &intel_private.pcidev->dev,
|
|
|
|
"pg_start == 0x%.8lx, intel_private.gtt_entries == 0x%.8x\n",
|
|
|
|
pg_start, intel_private.gtt_entries);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_info(&intel_private.pcidev->dev,
|
|
|
|
"trying to insert into local/stolen memory\n");
|
2007-01-23 09:33:43 +00:00
|
|
|
goto out_err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((pg_start + mem->page_count) > num_entries)
|
2007-01-23 09:33:43 +00:00
|
|
|
goto out_err;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* The i830 can't check the GTT for entries since its read only,
|
|
|
|
* depend on the caller to make the correct offset decisions.
|
|
|
|
*/
|
|
|
|
|
2007-01-23 09:33:43 +00:00
|
|
|
if (type != mem->type)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
mask_type = agp_bridge->driver->agp_type_to_mask_type(agp_bridge, type);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-01-23 09:33:43 +00:00
|
|
|
if (mask_type != 0 && mask_type != AGP_PHYS_MEMORY &&
|
|
|
|
mask_type != INTEL_AGP_CACHED_MEMORY)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
if (!mem->is_flushed)
|
2006-12-20 15:33:41 +00:00
|
|
|
global_cache_flush();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
for (i = 0, j = pg_start; i < mem->page_count; i++, j++) {
|
|
|
|
writel(agp_bridge->driver->mask_memory(agp_bridge,
|
2007-01-23 09:33:43 +00:00
|
|
|
mem->memory[i], mask_type),
|
2007-05-30 01:40:46 +00:00
|
|
|
intel_private.registers+I810_PTE_BASE+(j*4));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-05-30 01:40:46 +00:00
|
|
|
readl(intel_private.registers+I810_PTE_BASE+((j-1)*4));
|
2005-04-16 22:20:36 +00:00
|
|
|
agp_bridge->driver->tlb_flush(mem);
|
2007-01-23 09:33:43 +00:00
|
|
|
|
|
|
|
out:
|
|
|
|
ret = 0;
|
|
|
|
out_err:
|
2008-06-19 00:42:17 +00:00
|
|
|
mem->is_flushed = true;
|
2007-01-23 09:33:43 +00:00
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-01-25 01:23:04 +00:00
|
|
|
static int intel_i830_remove_entries(struct agp_memory *mem, off_t pg_start,
|
|
|
|
int type)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2006-12-20 15:33:41 +00:00
|
|
|
if (mem->page_count == 0)
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
if (pg_start < intel_private.gtt_entries) {
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_info(&intel_private.pcidev->dev,
|
|
|
|
"trying to disable local/stolen memory\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = pg_start; i < (mem->page_count + pg_start); i++) {
|
2007-05-30 01:40:46 +00:00
|
|
|
writel(agp_bridge->scratch_page, intel_private.registers+I810_PTE_BASE+(i*4));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-05-30 01:40:46 +00:00
|
|
|
readl(intel_private.registers+I810_PTE_BASE+((i-1)*4));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
agp_bridge->driver->tlb_flush(mem);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-01-25 01:23:04 +00:00
|
|
|
static struct agp_memory *intel_i830_alloc_by_type(size_t pg_count, int type)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
if (type == AGP_PHYS_MEMORY)
|
|
|
|
return alloc_agpphysmem_i8xx(pg_count, type);
|
|
|
|
/* always return NULL for other allocation types for now */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-10-29 08:06:10 +00:00
|
|
|
static int intel_alloc_chipset_flush_resource(void)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
ret = pci_bus_alloc_resource(agp_bridge->dev->bus, &intel_private.ifp_resource, PAGE_SIZE,
|
|
|
|
PAGE_SIZE, PCIBIOS_MIN_MEM, 0,
|
|
|
|
pcibios_align_resource, agp_bridge->dev);
|
|
|
|
|
2007-11-21 06:36:31 +00:00
|
|
|
return ret;
|
2007-10-29 08:06:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_i915_setup_chipset_flush(void)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u32 temp;
|
|
|
|
|
|
|
|
pci_read_config_dword(agp_bridge->dev, I915_IFPADDR, &temp);
|
|
|
|
if (!(temp & 0x1)) {
|
|
|
|
intel_alloc_chipset_flush_resource();
|
2008-01-23 05:34:29 +00:00
|
|
|
intel_private.resource_valid = 1;
|
2007-10-29 08:06:10 +00:00
|
|
|
pci_write_config_dword(agp_bridge->dev, I915_IFPADDR, (intel_private.ifp_resource.start & 0xffffffff) | 0x1);
|
|
|
|
} else {
|
|
|
|
temp &= ~1;
|
|
|
|
|
2008-01-23 05:34:29 +00:00
|
|
|
intel_private.resource_valid = 1;
|
2007-10-29 08:06:10 +00:00
|
|
|
intel_private.ifp_resource.start = temp;
|
|
|
|
intel_private.ifp_resource.end = temp + PAGE_SIZE;
|
|
|
|
ret = request_resource(&iomem_resource, &intel_private.ifp_resource);
|
2008-01-23 05:34:29 +00:00
|
|
|
/* some BIOSes reserve this area in a pnp some don't */
|
|
|
|
if (ret)
|
|
|
|
intel_private.resource_valid = 0;
|
2007-10-29 08:06:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_i965_g33_setup_chipset_flush(void)
|
|
|
|
{
|
|
|
|
u32 temp_hi, temp_lo;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
pci_read_config_dword(agp_bridge->dev, I965_IFPADDR + 4, &temp_hi);
|
|
|
|
pci_read_config_dword(agp_bridge->dev, I965_IFPADDR, &temp_lo);
|
|
|
|
|
|
|
|
if (!(temp_lo & 0x1)) {
|
|
|
|
|
|
|
|
intel_alloc_chipset_flush_resource();
|
|
|
|
|
2008-01-23 05:34:29 +00:00
|
|
|
intel_private.resource_valid = 1;
|
2007-11-29 00:00:48 +00:00
|
|
|
pci_write_config_dword(agp_bridge->dev, I965_IFPADDR + 4,
|
|
|
|
upper_32_bits(intel_private.ifp_resource.start));
|
2007-10-29 08:06:10 +00:00
|
|
|
pci_write_config_dword(agp_bridge->dev, I965_IFPADDR, (intel_private.ifp_resource.start & 0xffffffff) | 0x1);
|
|
|
|
} else {
|
|
|
|
u64 l64;
|
2008-01-25 01:23:04 +00:00
|
|
|
|
2007-10-29 08:06:10 +00:00
|
|
|
temp_lo &= ~0x1;
|
|
|
|
l64 = ((u64)temp_hi << 32) | temp_lo;
|
|
|
|
|
2008-01-23 05:34:29 +00:00
|
|
|
intel_private.resource_valid = 1;
|
2007-10-29 08:06:10 +00:00
|
|
|
intel_private.ifp_resource.start = l64;
|
|
|
|
intel_private.ifp_resource.end = l64 + PAGE_SIZE;
|
|
|
|
ret = request_resource(&iomem_resource, &intel_private.ifp_resource);
|
2008-01-23 05:34:29 +00:00
|
|
|
/* some BIOSes reserve this area in a pnp some don't */
|
|
|
|
if (ret)
|
|
|
|
intel_private.resource_valid = 0;
|
2007-10-29 08:06:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-11-21 06:36:31 +00:00
|
|
|
static void intel_i9xx_setup_flush(void)
|
|
|
|
{
|
2008-01-23 05:34:29 +00:00
|
|
|
/* return if already configured */
|
|
|
|
if (intel_private.ifp_resource.start)
|
|
|
|
return;
|
2007-11-21 06:36:31 +00:00
|
|
|
|
2008-01-23 05:34:29 +00:00
|
|
|
/* setup a resource for this object */
|
2007-11-21 06:36:31 +00:00
|
|
|
intel_private.ifp_resource.name = "Intel Flush Page";
|
|
|
|
intel_private.ifp_resource.flags = IORESOURCE_MEM;
|
|
|
|
|
|
|
|
/* Setup chipset flush for 915 */
|
2008-06-20 01:48:06 +00:00
|
|
|
if (IS_I965 || IS_G33 || IS_G4X) {
|
2007-11-21 06:36:31 +00:00
|
|
|
intel_i965_g33_setup_chipset_flush();
|
|
|
|
} else {
|
|
|
|
intel_i915_setup_chipset_flush();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (intel_private.ifp_resource.start) {
|
|
|
|
intel_private.i9xx_flush_page = ioremap_nocache(intel_private.ifp_resource.start, PAGE_SIZE);
|
|
|
|
if (!intel_private.i9xx_flush_page)
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_info(&intel_private.pcidev->dev, "can't ioremap flush page - no chipset flushing");
|
2007-11-21 06:36:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int intel_i915_configure(void)
|
|
|
|
{
|
|
|
|
struct aper_size_info_fixed *current_size;
|
|
|
|
u32 temp;
|
|
|
|
u16 gmch_ctrl;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
current_size = A_SIZE_FIX(agp_bridge->current_size);
|
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
pci_read_config_dword(intel_private.pcidev, I915_GMADDR, &temp);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
|
|
|
|
|
2008-01-25 01:23:04 +00:00
|
|
|
pci_read_config_word(agp_bridge->dev, I830_GMCH_CTRL, &gmch_ctrl);
|
2005-04-16 22:20:36 +00:00
|
|
|
gmch_ctrl |= I830_GMCH_ENABLED;
|
2008-01-25 01:23:04 +00:00
|
|
|
pci_write_config_word(agp_bridge->dev, I830_GMCH_CTRL, gmch_ctrl);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
writel(agp_bridge->gatt_bus_addr|I810_PGETBL_ENABLED, intel_private.registers+I810_PGETBL_CTL);
|
|
|
|
readl(intel_private.registers+I810_PGETBL_CTL); /* PCI Posting. */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (agp_bridge->driver->needs_scratch_page) {
|
2007-05-30 01:40:46 +00:00
|
|
|
for (i = intel_private.gtt_entries; i < current_size->num_entries; i++) {
|
|
|
|
writel(agp_bridge->scratch_page, intel_private.gtt+i);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-10-15 00:18:45 +00:00
|
|
|
readl(intel_private.gtt+i-1); /* PCI Posting. */
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
global_cache_flush();
|
2007-10-29 08:06:10 +00:00
|
|
|
|
2007-11-21 06:36:31 +00:00
|
|
|
intel_i9xx_setup_flush();
|
2008-01-25 01:23:04 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_i915_cleanup(void)
|
|
|
|
{
|
2007-11-21 06:36:31 +00:00
|
|
|
if (intel_private.i9xx_flush_page)
|
|
|
|
iounmap(intel_private.i9xx_flush_page);
|
2008-01-23 05:34:29 +00:00
|
|
|
if (intel_private.resource_valid)
|
|
|
|
release_resource(&intel_private.ifp_resource);
|
|
|
|
intel_private.ifp_resource.start = 0;
|
|
|
|
intel_private.resource_valid = 0;
|
2007-05-30 01:40:46 +00:00
|
|
|
iounmap(intel_private.gtt);
|
|
|
|
iounmap(intel_private.registers);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-10-29 08:06:10 +00:00
|
|
|
static void intel_i915_chipset_flush(struct agp_bridge_data *bridge)
|
|
|
|
{
|
2007-11-21 06:36:31 +00:00
|
|
|
if (intel_private.i9xx_flush_page)
|
|
|
|
writel(1, intel_private.i9xx_flush_page);
|
2007-10-29 08:06:10 +00:00
|
|
|
}
|
|
|
|
|
2008-01-25 01:23:04 +00:00
|
|
|
static int intel_i915_insert_entries(struct agp_memory *mem, off_t pg_start,
|
|
|
|
int type)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-01-25 01:23:04 +00:00
|
|
|
int i, j, num_entries;
|
2005-04-16 22:20:36 +00:00
|
|
|
void *temp;
|
2007-01-23 09:33:43 +00:00
|
|
|
int ret = -EINVAL;
|
|
|
|
int mask_type;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-20 15:33:41 +00:00
|
|
|
if (mem->page_count == 0)
|
2007-01-23 09:33:43 +00:00
|
|
|
goto out;
|
2006-12-20 15:33:41 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
temp = agp_bridge->current_size;
|
|
|
|
num_entries = A_SIZE_FIX(temp)->num_entries;
|
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
if (pg_start < intel_private.gtt_entries) {
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_printk(KERN_DEBUG, &intel_private.pcidev->dev,
|
|
|
|
"pg_start == 0x%.8lx, intel_private.gtt_entries == 0x%.8x\n",
|
|
|
|
pg_start, intel_private.gtt_entries);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_info(&intel_private.pcidev->dev,
|
|
|
|
"trying to insert into local/stolen memory\n");
|
2007-01-23 09:33:43 +00:00
|
|
|
goto out_err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((pg_start + mem->page_count) > num_entries)
|
2007-01-23 09:33:43 +00:00
|
|
|
goto out_err;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-01-23 09:33:43 +00:00
|
|
|
/* The i915 can't check the GTT for entries since its read only,
|
2005-04-16 22:20:36 +00:00
|
|
|
* depend on the caller to make the correct offset decisions.
|
|
|
|
*/
|
|
|
|
|
2007-01-23 09:33:43 +00:00
|
|
|
if (type != mem->type)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
mask_type = agp_bridge->driver->agp_type_to_mask_type(agp_bridge, type);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-01-23 09:33:43 +00:00
|
|
|
if (mask_type != 0 && mask_type != AGP_PHYS_MEMORY &&
|
|
|
|
mask_type != INTEL_AGP_CACHED_MEMORY)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
if (!mem->is_flushed)
|
2006-12-20 15:33:41 +00:00
|
|
|
global_cache_flush();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
for (i = 0, j = pg_start; i < mem->page_count; i++, j++) {
|
|
|
|
writel(agp_bridge->driver->mask_memory(agp_bridge,
|
2007-05-30 01:40:46 +00:00
|
|
|
mem->memory[i], mask_type), intel_private.gtt+j);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
readl(intel_private.gtt+j-1);
|
2005-04-16 22:20:36 +00:00
|
|
|
agp_bridge->driver->tlb_flush(mem);
|
2007-01-23 09:33:43 +00:00
|
|
|
|
|
|
|
out:
|
|
|
|
ret = 0;
|
|
|
|
out_err:
|
2008-06-19 00:42:17 +00:00
|
|
|
mem->is_flushed = true;
|
2007-01-23 09:33:43 +00:00
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-01-25 01:23:04 +00:00
|
|
|
static int intel_i915_remove_entries(struct agp_memory *mem, off_t pg_start,
|
|
|
|
int type)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2006-12-20 15:33:41 +00:00
|
|
|
if (mem->page_count == 0)
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
if (pg_start < intel_private.gtt_entries) {
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_info(&intel_private.pcidev->dev,
|
|
|
|
"trying to disable local/stolen memory\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-01-25 01:23:04 +00:00
|
|
|
for (i = pg_start; i < (mem->page_count + pg_start); i++)
|
2007-05-30 01:40:46 +00:00
|
|
|
writel(agp_bridge->scratch_page, intel_private.gtt+i);
|
2008-01-25 01:23:04 +00:00
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
readl(intel_private.gtt+i-1);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
agp_bridge->driver->tlb_flush(mem);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-12-19 20:57:24 +00:00
|
|
|
/* Return the aperture size by just checking the resource length. The effect
|
|
|
|
* described in the spec of the MSAC registers is just changing of the
|
|
|
|
* resource size.
|
|
|
|
*/
|
|
|
|
static int intel_i9xx_fetch_size(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-02-06 16:08:28 +00:00
|
|
|
int num_sizes = ARRAY_SIZE(intel_i830_sizes);
|
2006-12-19 20:57:24 +00:00
|
|
|
int aper_size; /* size in megabytes */
|
|
|
|
int i;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
aper_size = pci_resource_len(intel_private.pcidev, 2) / MB(1);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-19 20:57:24 +00:00
|
|
|
for (i = 0; i < num_sizes; i++) {
|
|
|
|
if (aper_size == intel_i830_sizes[i].size) {
|
|
|
|
agp_bridge->current_size = intel_i830_sizes + i;
|
|
|
|
agp_bridge->previous_size = agp_bridge->current_size;
|
|
|
|
return aper_size;
|
|
|
|
}
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-19 20:57:24 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* The intel i915 automatically initializes the agp aperture during POST.
|
|
|
|
* Use the memory already set aside for in the GTT.
|
|
|
|
*/
|
|
|
|
static int intel_i915_create_gatt_table(struct agp_bridge_data *bridge)
|
|
|
|
{
|
|
|
|
int page_order;
|
|
|
|
struct aper_size_info_fixed *size;
|
|
|
|
int num_entries;
|
|
|
|
u32 temp, temp2;
|
2007-09-11 22:23:58 +00:00
|
|
|
int gtt_map_size = 256 * 1024;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
size = agp_bridge->current_size;
|
|
|
|
page_order = size->page_order;
|
|
|
|
num_entries = size->num_entries;
|
|
|
|
agp_bridge->gatt_table_real = NULL;
|
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
pci_read_config_dword(intel_private.pcidev, I915_MMADDR, &temp);
|
2008-01-25 01:23:04 +00:00
|
|
|
pci_read_config_dword(intel_private.pcidev, I915_PTEADDR, &temp2);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-09-11 22:23:58 +00:00
|
|
|
if (IS_G33)
|
|
|
|
gtt_map_size = 1024 * 1024; /* 1M on G33 */
|
|
|
|
intel_private.gtt = ioremap(temp2, gtt_map_size);
|
2007-05-30 01:40:46 +00:00
|
|
|
if (!intel_private.gtt)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
temp &= 0xfff80000;
|
|
|
|
|
2008-01-25 01:23:04 +00:00
|
|
|
intel_private.registers = ioremap(temp, 128 * 4096);
|
2007-08-25 08:14:00 +00:00
|
|
|
if (!intel_private.registers) {
|
|
|
|
iounmap(intel_private.gtt);
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENOMEM;
|
2007-08-25 08:14:00 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
temp = readl(intel_private.registers+I810_PGETBL_CTL) & 0xfffff000;
|
2005-04-16 22:20:36 +00:00
|
|
|
global_cache_flush(); /* FIXME: ? */
|
|
|
|
|
|
|
|
/* we have to call this as early as possible after the MMIO base address is known */
|
|
|
|
intel_i830_init_gtt_entries();
|
|
|
|
|
|
|
|
agp_bridge->gatt_table = NULL;
|
|
|
|
|
|
|
|
agp_bridge->gatt_bus_addr = temp;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2006-11-22 17:37:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The i965 supports 36-bit physical addresses, but to keep
|
|
|
|
* the format of the GTT the same, the bits that don't fit
|
|
|
|
* in a 32-bit word are shifted down to bits 4..7.
|
|
|
|
*
|
|
|
|
* Gcc is smart enough to notice that "(addr >> 28) & 0xf0"
|
|
|
|
* is always zero on 32-bit architectures, so no need to make
|
|
|
|
* this conditional.
|
|
|
|
*/
|
|
|
|
static unsigned long intel_i965_mask_memory(struct agp_bridge_data *bridge,
|
|
|
|
unsigned long addr, int type)
|
|
|
|
{
|
|
|
|
/* Shift high bits down */
|
|
|
|
addr |= (addr >> 28) & 0xf0;
|
|
|
|
|
|
|
|
/* Type checking must be done elsewhere */
|
|
|
|
return addr | bridge->driver->masks[type].mask;
|
|
|
|
}
|
|
|
|
|
2008-06-19 04:17:58 +00:00
|
|
|
static void intel_i965_get_gtt_range(int *gtt_offset, int *gtt_size)
|
|
|
|
{
|
|
|
|
switch (agp_bridge->dev->device) {
|
2008-07-30 19:26:50 +00:00
|
|
|
case PCI_DEVICE_ID_INTEL_GM45_HB:
|
2008-06-19 04:17:58 +00:00
|
|
|
case PCI_DEVICE_ID_INTEL_IGD_E_HB:
|
|
|
|
case PCI_DEVICE_ID_INTEL_Q45_HB:
|
|
|
|
case PCI_DEVICE_ID_INTEL_G45_HB:
|
2008-11-17 06:39:00 +00:00
|
|
|
case PCI_DEVICE_ID_INTEL_G41_HB:
|
2008-06-19 04:17:58 +00:00
|
|
|
*gtt_offset = *gtt_size = MB(2);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
*gtt_offset = *gtt_size = KB(512);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-09-06 15:57:18 +00:00
|
|
|
/* The intel i965 automatically initializes the agp aperture during POST.
|
2006-12-19 20:57:24 +00:00
|
|
|
* Use the memory already set aside for in the GTT.
|
|
|
|
*/
|
2006-09-06 15:57:18 +00:00
|
|
|
static int intel_i965_create_gatt_table(struct agp_bridge_data *bridge)
|
|
|
|
{
|
2008-06-19 04:27:53 +00:00
|
|
|
int page_order;
|
|
|
|
struct aper_size_info_fixed *size;
|
|
|
|
int num_entries;
|
|
|
|
u32 temp;
|
|
|
|
int gtt_offset, gtt_size;
|
2006-09-06 15:57:18 +00:00
|
|
|
|
2008-06-19 04:27:53 +00:00
|
|
|
size = agp_bridge->current_size;
|
|
|
|
page_order = size->page_order;
|
|
|
|
num_entries = size->num_entries;
|
|
|
|
agp_bridge->gatt_table_real = NULL;
|
2006-09-06 15:57:18 +00:00
|
|
|
|
2008-06-19 04:27:53 +00:00
|
|
|
pci_read_config_dword(intel_private.pcidev, I915_MMADDR, &temp);
|
2006-09-06 15:57:18 +00:00
|
|
|
|
2008-06-19 04:27:53 +00:00
|
|
|
temp &= 0xfff00000;
|
2006-09-06 15:57:18 +00:00
|
|
|
|
2008-06-19 04:17:58 +00:00
|
|
|
intel_i965_get_gtt_range(>t_offset, >t_size);
|
2008-01-23 04:54:37 +00:00
|
|
|
|
2008-06-19 04:27:53 +00:00
|
|
|
intel_private.gtt = ioremap((temp + gtt_offset) , gtt_size);
|
2006-09-06 15:57:18 +00:00
|
|
|
|
2008-06-19 04:27:53 +00:00
|
|
|
if (!intel_private.gtt)
|
|
|
|
return -ENOMEM;
|
2006-09-06 15:57:18 +00:00
|
|
|
|
2008-06-19 04:27:53 +00:00
|
|
|
intel_private.registers = ioremap(temp, 128 * 4096);
|
|
|
|
if (!intel_private.registers) {
|
2007-08-25 08:14:00 +00:00
|
|
|
iounmap(intel_private.gtt);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2006-09-06 15:57:18 +00:00
|
|
|
|
2008-06-19 04:27:53 +00:00
|
|
|
temp = readl(intel_private.registers+I810_PGETBL_CTL) & 0xfffff000;
|
|
|
|
global_cache_flush(); /* FIXME: ? */
|
2006-09-06 15:57:18 +00:00
|
|
|
|
2008-06-19 04:27:53 +00:00
|
|
|
/* we have to call this as early as possible after the MMIO base address is known */
|
|
|
|
intel_i830_init_gtt_entries();
|
2006-09-06 15:57:18 +00:00
|
|
|
|
2008-06-19 04:27:53 +00:00
|
|
|
agp_bridge->gatt_table = NULL;
|
2006-09-06 15:57:18 +00:00
|
|
|
|
2008-06-19 04:27:53 +00:00
|
|
|
agp_bridge->gatt_bus_addr = temp;
|
2006-09-06 15:57:18 +00:00
|
|
|
|
2008-06-19 04:27:53 +00:00
|
|
|
return 0;
|
2006-09-06 15:57:18 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static int intel_fetch_size(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
u16 temp;
|
|
|
|
struct aper_size_info_16 *values;
|
|
|
|
|
|
|
|
pci_read_config_word(agp_bridge->dev, INTEL_APSIZE, &temp);
|
|
|
|
values = A_SIZE_16(agp_bridge->driver->aperture_sizes);
|
|
|
|
|
|
|
|
for (i = 0; i < agp_bridge->driver->num_aperture_sizes; i++) {
|
|
|
|
if (temp == values[i].size_value) {
|
|
|
|
agp_bridge->previous_size = agp_bridge->current_size = (void *) (values + i);
|
|
|
|
agp_bridge->aperture_size_idx = i;
|
|
|
|
return values[i].size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __intel_8xx_fetch_size(u8 temp)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct aper_size_info_8 *values;
|
|
|
|
|
|
|
|
values = A_SIZE_8(agp_bridge->driver->aperture_sizes);
|
|
|
|
|
|
|
|
for (i = 0; i < agp_bridge->driver->num_aperture_sizes; i++) {
|
|
|
|
if (temp == values[i].size_value) {
|
|
|
|
agp_bridge->previous_size =
|
|
|
|
agp_bridge->current_size = (void *) (values + i);
|
|
|
|
agp_bridge->aperture_size_idx = i;
|
|
|
|
return values[i].size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int intel_8xx_fetch_size(void)
|
|
|
|
{
|
|
|
|
u8 temp;
|
|
|
|
|
|
|
|
pci_read_config_byte(agp_bridge->dev, INTEL_APSIZE, &temp);
|
|
|
|
return __intel_8xx_fetch_size(temp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int intel_815_fetch_size(void)
|
|
|
|
{
|
|
|
|
u8 temp;
|
|
|
|
|
|
|
|
/* Intel 815 chipsets have a _weird_ APSIZE register with only
|
|
|
|
* one non-reserved bit, so mask the others out ... */
|
|
|
|
pci_read_config_byte(agp_bridge->dev, INTEL_APSIZE, &temp);
|
|
|
|
temp &= (1 << 3);
|
|
|
|
|
|
|
|
return __intel_8xx_fetch_size(temp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_tlbflush(struct agp_memory *mem)
|
|
|
|
{
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_AGPCTRL, 0x2200);
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_AGPCTRL, 0x2280);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void intel_8xx_tlbflush(struct agp_memory *mem)
|
|
|
|
{
|
|
|
|
u32 temp;
|
|
|
|
pci_read_config_dword(agp_bridge->dev, INTEL_AGPCTRL, &temp);
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_AGPCTRL, temp & ~(1 << 7));
|
|
|
|
pci_read_config_dword(agp_bridge->dev, INTEL_AGPCTRL, &temp);
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_AGPCTRL, temp | (1 << 7));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void intel_cleanup(void)
|
|
|
|
{
|
|
|
|
u16 temp;
|
|
|
|
struct aper_size_info_16 *previous_size;
|
|
|
|
|
|
|
|
previous_size = A_SIZE_16(agp_bridge->previous_size);
|
|
|
|
pci_read_config_word(agp_bridge->dev, INTEL_NBXCFG, &temp);
|
|
|
|
pci_write_config_word(agp_bridge->dev, INTEL_NBXCFG, temp & ~(1 << 9));
|
|
|
|
pci_write_config_word(agp_bridge->dev, INTEL_APSIZE, previous_size->size_value);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void intel_8xx_cleanup(void)
|
|
|
|
{
|
|
|
|
u16 temp;
|
|
|
|
struct aper_size_info_8 *previous_size;
|
|
|
|
|
|
|
|
previous_size = A_SIZE_8(agp_bridge->previous_size);
|
|
|
|
pci_read_config_word(agp_bridge->dev, INTEL_NBXCFG, &temp);
|
|
|
|
pci_write_config_word(agp_bridge->dev, INTEL_NBXCFG, temp & ~(1 << 9));
|
|
|
|
pci_write_config_byte(agp_bridge->dev, INTEL_APSIZE, previous_size->size_value);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int intel_configure(void)
|
|
|
|
{
|
|
|
|
u32 temp;
|
|
|
|
u16 temp2;
|
|
|
|
struct aper_size_info_16 *current_size;
|
|
|
|
|
|
|
|
current_size = A_SIZE_16(agp_bridge->current_size);
|
|
|
|
|
|
|
|
/* aperture size */
|
|
|
|
pci_write_config_word(agp_bridge->dev, INTEL_APSIZE, current_size->size_value);
|
|
|
|
|
|
|
|
/* address to map to */
|
|
|
|
pci_read_config_dword(agp_bridge->dev, AGP_APBASE, &temp);
|
|
|
|
agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
|
|
|
|
|
|
|
|
/* attbase - aperture base */
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_ATTBASE, agp_bridge->gatt_bus_addr);
|
|
|
|
|
|
|
|
/* agpctrl */
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_AGPCTRL, 0x2280);
|
|
|
|
|
|
|
|
/* paccfg/nbxcfg */
|
|
|
|
pci_read_config_word(agp_bridge->dev, INTEL_NBXCFG, &temp2);
|
|
|
|
pci_write_config_word(agp_bridge->dev, INTEL_NBXCFG,
|
|
|
|
(temp2 & ~(1 << 10)) | (1 << 9));
|
|
|
|
/* clear any possible error conditions */
|
|
|
|
pci_write_config_byte(agp_bridge->dev, INTEL_ERRSTS + 1, 7);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int intel_815_configure(void)
|
|
|
|
{
|
|
|
|
u32 temp, addr;
|
|
|
|
u8 temp2;
|
|
|
|
struct aper_size_info_8 *current_size;
|
|
|
|
|
|
|
|
/* attbase - aperture base */
|
|
|
|
/* the Intel 815 chipset spec. says that bits 29-31 in the
|
|
|
|
* ATTBASE register are reserved -> try not to write them */
|
|
|
|
if (agp_bridge->gatt_bus_addr & INTEL_815_ATTBASE_MASK) {
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_emerg(&agp_bridge->dev->dev, "gatt bus addr too high");
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
current_size = A_SIZE_8(agp_bridge->current_size);
|
|
|
|
|
|
|
|
/* aperture size */
|
|
|
|
pci_write_config_byte(agp_bridge->dev, INTEL_APSIZE,
|
|
|
|
current_size->size_value);
|
|
|
|
|
|
|
|
/* address to map to */
|
|
|
|
pci_read_config_dword(agp_bridge->dev, AGP_APBASE, &temp);
|
|
|
|
agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
|
|
|
|
|
|
|
|
pci_read_config_dword(agp_bridge->dev, INTEL_ATTBASE, &addr);
|
|
|
|
addr &= INTEL_815_ATTBASE_MASK;
|
|
|
|
addr |= agp_bridge->gatt_bus_addr;
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_ATTBASE, addr);
|
|
|
|
|
|
|
|
/* agpctrl */
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_AGPCTRL, 0x0000);
|
|
|
|
|
|
|
|
/* apcont */
|
|
|
|
pci_read_config_byte(agp_bridge->dev, INTEL_815_APCONT, &temp2);
|
|
|
|
pci_write_config_byte(agp_bridge->dev, INTEL_815_APCONT, temp2 | (1 << 1));
|
|
|
|
|
|
|
|
/* clear any possible error conditions */
|
|
|
|
/* Oddness : this chipset seems to have no ERRSTS register ! */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_820_tlbflush(struct agp_memory *mem)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_820_cleanup(void)
|
|
|
|
{
|
|
|
|
u8 temp;
|
|
|
|
struct aper_size_info_8 *previous_size;
|
|
|
|
|
|
|
|
previous_size = A_SIZE_8(agp_bridge->previous_size);
|
|
|
|
pci_read_config_byte(agp_bridge->dev, INTEL_I820_RDCR, &temp);
|
|
|
|
pci_write_config_byte(agp_bridge->dev, INTEL_I820_RDCR,
|
|
|
|
temp & ~(1 << 1));
|
|
|
|
pci_write_config_byte(agp_bridge->dev, INTEL_APSIZE,
|
|
|
|
previous_size->size_value);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int intel_820_configure(void)
|
|
|
|
{
|
|
|
|
u32 temp;
|
|
|
|
u8 temp2;
|
|
|
|
struct aper_size_info_8 *current_size;
|
|
|
|
|
|
|
|
current_size = A_SIZE_8(agp_bridge->current_size);
|
|
|
|
|
|
|
|
/* aperture size */
|
|
|
|
pci_write_config_byte(agp_bridge->dev, INTEL_APSIZE, current_size->size_value);
|
|
|
|
|
|
|
|
/* address to map to */
|
|
|
|
pci_read_config_dword(agp_bridge->dev, AGP_APBASE, &temp);
|
|
|
|
agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
|
|
|
|
|
|
|
|
/* attbase - aperture base */
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_ATTBASE, agp_bridge->gatt_bus_addr);
|
|
|
|
|
|
|
|
/* agpctrl */
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_AGPCTRL, 0x0000);
|
|
|
|
|
|
|
|
/* global enable aperture access */
|
|
|
|
/* This flag is not accessed through MCHCFG register as in */
|
|
|
|
/* i850 chipset. */
|
|
|
|
pci_read_config_byte(agp_bridge->dev, INTEL_I820_RDCR, &temp2);
|
|
|
|
pci_write_config_byte(agp_bridge->dev, INTEL_I820_RDCR, temp2 | (1 << 1));
|
|
|
|
/* clear any possible AGP-related error conditions */
|
|
|
|
pci_write_config_word(agp_bridge->dev, INTEL_I820_ERRSTS, 0x001c);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int intel_840_configure(void)
|
|
|
|
{
|
|
|
|
u32 temp;
|
|
|
|
u16 temp2;
|
|
|
|
struct aper_size_info_8 *current_size;
|
|
|
|
|
|
|
|
current_size = A_SIZE_8(agp_bridge->current_size);
|
|
|
|
|
|
|
|
/* aperture size */
|
|
|
|
pci_write_config_byte(agp_bridge->dev, INTEL_APSIZE, current_size->size_value);
|
|
|
|
|
|
|
|
/* address to map to */
|
|
|
|
pci_read_config_dword(agp_bridge->dev, AGP_APBASE, &temp);
|
|
|
|
agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
|
|
|
|
|
|
|
|
/* attbase - aperture base */
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_ATTBASE, agp_bridge->gatt_bus_addr);
|
|
|
|
|
|
|
|
/* agpctrl */
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_AGPCTRL, 0x0000);
|
|
|
|
|
|
|
|
/* mcgcfg */
|
|
|
|
pci_read_config_word(agp_bridge->dev, INTEL_I840_MCHCFG, &temp2);
|
|
|
|
pci_write_config_word(agp_bridge->dev, INTEL_I840_MCHCFG, temp2 | (1 << 9));
|
|
|
|
/* clear any possible error conditions */
|
|
|
|
pci_write_config_word(agp_bridge->dev, INTEL_I840_ERRSTS, 0xc000);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int intel_845_configure(void)
|
|
|
|
{
|
|
|
|
u32 temp;
|
|
|
|
u8 temp2;
|
|
|
|
struct aper_size_info_8 *current_size;
|
|
|
|
|
|
|
|
current_size = A_SIZE_8(agp_bridge->current_size);
|
|
|
|
|
|
|
|
/* aperture size */
|
|
|
|
pci_write_config_byte(agp_bridge->dev, INTEL_APSIZE, current_size->size_value);
|
|
|
|
|
2005-07-29 21:03:39 +00:00
|
|
|
if (agp_bridge->apbase_config != 0) {
|
|
|
|
pci_write_config_dword(agp_bridge->dev, AGP_APBASE,
|
|
|
|
agp_bridge->apbase_config);
|
|
|
|
} else {
|
|
|
|
/* address to map to */
|
|
|
|
pci_read_config_dword(agp_bridge->dev, AGP_APBASE, &temp);
|
|
|
|
agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
|
|
|
|
agp_bridge->apbase_config = temp;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* attbase - aperture base */
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_ATTBASE, agp_bridge->gatt_bus_addr);
|
|
|
|
|
|
|
|
/* agpctrl */
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_AGPCTRL, 0x0000);
|
|
|
|
|
|
|
|
/* agpm */
|
|
|
|
pci_read_config_byte(agp_bridge->dev, INTEL_I845_AGPM, &temp2);
|
|
|
|
pci_write_config_byte(agp_bridge->dev, INTEL_I845_AGPM, temp2 | (1 << 1));
|
|
|
|
/* clear any possible error conditions */
|
|
|
|
pci_write_config_word(agp_bridge->dev, INTEL_I845_ERRSTS, 0x001c);
|
2007-11-21 06:36:31 +00:00
|
|
|
|
|
|
|
intel_i830_setup_flush();
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int intel_850_configure(void)
|
|
|
|
{
|
|
|
|
u32 temp;
|
|
|
|
u16 temp2;
|
|
|
|
struct aper_size_info_8 *current_size;
|
|
|
|
|
|
|
|
current_size = A_SIZE_8(agp_bridge->current_size);
|
|
|
|
|
|
|
|
/* aperture size */
|
|
|
|
pci_write_config_byte(agp_bridge->dev, INTEL_APSIZE, current_size->size_value);
|
|
|
|
|
|
|
|
/* address to map to */
|
|
|
|
pci_read_config_dword(agp_bridge->dev, AGP_APBASE, &temp);
|
|
|
|
agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
|
|
|
|
|
|
|
|
/* attbase - aperture base */
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_ATTBASE, agp_bridge->gatt_bus_addr);
|
|
|
|
|
|
|
|
/* agpctrl */
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_AGPCTRL, 0x0000);
|
|
|
|
|
|
|
|
/* mcgcfg */
|
|
|
|
pci_read_config_word(agp_bridge->dev, INTEL_I850_MCHCFG, &temp2);
|
|
|
|
pci_write_config_word(agp_bridge->dev, INTEL_I850_MCHCFG, temp2 | (1 << 9));
|
|
|
|
/* clear any possible AGP-related error conditions */
|
|
|
|
pci_write_config_word(agp_bridge->dev, INTEL_I850_ERRSTS, 0x001c);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int intel_860_configure(void)
|
|
|
|
{
|
|
|
|
u32 temp;
|
|
|
|
u16 temp2;
|
|
|
|
struct aper_size_info_8 *current_size;
|
|
|
|
|
|
|
|
current_size = A_SIZE_8(agp_bridge->current_size);
|
|
|
|
|
|
|
|
/* aperture size */
|
|
|
|
pci_write_config_byte(agp_bridge->dev, INTEL_APSIZE, current_size->size_value);
|
|
|
|
|
|
|
|
/* address to map to */
|
|
|
|
pci_read_config_dword(agp_bridge->dev, AGP_APBASE, &temp);
|
|
|
|
agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
|
|
|
|
|
|
|
|
/* attbase - aperture base */
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_ATTBASE, agp_bridge->gatt_bus_addr);
|
|
|
|
|
|
|
|
/* agpctrl */
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_AGPCTRL, 0x0000);
|
|
|
|
|
|
|
|
/* mcgcfg */
|
|
|
|
pci_read_config_word(agp_bridge->dev, INTEL_I860_MCHCFG, &temp2);
|
|
|
|
pci_write_config_word(agp_bridge->dev, INTEL_I860_MCHCFG, temp2 | (1 << 9));
|
|
|
|
/* clear any possible AGP-related error conditions */
|
|
|
|
pci_write_config_word(agp_bridge->dev, INTEL_I860_ERRSTS, 0xf700);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int intel_830mp_configure(void)
|
|
|
|
{
|
|
|
|
u32 temp;
|
|
|
|
u16 temp2;
|
|
|
|
struct aper_size_info_8 *current_size;
|
|
|
|
|
|
|
|
current_size = A_SIZE_8(agp_bridge->current_size);
|
|
|
|
|
|
|
|
/* aperture size */
|
|
|
|
pci_write_config_byte(agp_bridge->dev, INTEL_APSIZE, current_size->size_value);
|
|
|
|
|
|
|
|
/* address to map to */
|
|
|
|
pci_read_config_dword(agp_bridge->dev, AGP_APBASE, &temp);
|
|
|
|
agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
|
|
|
|
|
|
|
|
/* attbase - aperture base */
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_ATTBASE, agp_bridge->gatt_bus_addr);
|
|
|
|
|
|
|
|
/* agpctrl */
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_AGPCTRL, 0x0000);
|
|
|
|
|
|
|
|
/* gmch */
|
|
|
|
pci_read_config_word(agp_bridge->dev, INTEL_NBXCFG, &temp2);
|
|
|
|
pci_write_config_word(agp_bridge->dev, INTEL_NBXCFG, temp2 | (1 << 9));
|
|
|
|
/* clear any possible AGP-related error conditions */
|
|
|
|
pci_write_config_word(agp_bridge->dev, INTEL_I830_ERRSTS, 0x1c);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int intel_7505_configure(void)
|
|
|
|
{
|
|
|
|
u32 temp;
|
|
|
|
u16 temp2;
|
|
|
|
struct aper_size_info_8 *current_size;
|
|
|
|
|
|
|
|
current_size = A_SIZE_8(agp_bridge->current_size);
|
|
|
|
|
|
|
|
/* aperture size */
|
|
|
|
pci_write_config_byte(agp_bridge->dev, INTEL_APSIZE, current_size->size_value);
|
|
|
|
|
|
|
|
/* address to map to */
|
|
|
|
pci_read_config_dword(agp_bridge->dev, AGP_APBASE, &temp);
|
|
|
|
agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
|
|
|
|
|
|
|
|
/* attbase - aperture base */
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_ATTBASE, agp_bridge->gatt_bus_addr);
|
|
|
|
|
|
|
|
/* agpctrl */
|
|
|
|
pci_write_config_dword(agp_bridge->dev, INTEL_AGPCTRL, 0x0000);
|
|
|
|
|
|
|
|
/* mchcfg */
|
|
|
|
pci_read_config_word(agp_bridge->dev, INTEL_I7505_MCHCFG, &temp2);
|
|
|
|
pci_write_config_word(agp_bridge->dev, INTEL_I7505_MCHCFG, temp2 | (1 << 9));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Setup function */
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct gatt_mask intel_generic_masks[] =
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
{.mask = 0x00000017, .type = 0}
|
|
|
|
};
|
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct aper_size_info_8 intel_815_sizes[2] =
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
{64, 16384, 4, 0},
|
|
|
|
{32, 8192, 3, 8},
|
|
|
|
};
|
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct aper_size_info_8 intel_8xx_sizes[7] =
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
{256, 65536, 6, 0},
|
|
|
|
{128, 32768, 5, 32},
|
|
|
|
{64, 16384, 4, 48},
|
|
|
|
{32, 8192, 3, 56},
|
|
|
|
{16, 4096, 2, 60},
|
|
|
|
{8, 2048, 1, 62},
|
|
|
|
{4, 1024, 0, 63}
|
|
|
|
};
|
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct aper_size_info_16 intel_generic_sizes[7] =
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
{256, 65536, 6, 0},
|
|
|
|
{128, 32768, 5, 32},
|
|
|
|
{64, 16384, 4, 48},
|
|
|
|
{32, 8192, 3, 56},
|
|
|
|
{16, 4096, 2, 60},
|
|
|
|
{8, 2048, 1, 62},
|
|
|
|
{4, 1024, 0, 63}
|
|
|
|
};
|
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct aper_size_info_8 intel_830mp_sizes[4] =
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
{256, 65536, 6, 0},
|
|
|
|
{128, 32768, 5, 32},
|
|
|
|
{64, 16384, 4, 48},
|
|
|
|
{32, 8192, 3, 56}
|
|
|
|
};
|
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct agp_bridge_driver intel_generic_driver = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.aperture_sizes = intel_generic_sizes,
|
|
|
|
.size_type = U16_APER_SIZE,
|
|
|
|
.num_aperture_sizes = 7,
|
|
|
|
.configure = intel_configure,
|
|
|
|
.fetch_size = intel_fetch_size,
|
|
|
|
.cleanup = intel_cleanup,
|
|
|
|
.tlb_flush = intel_tlbflush,
|
|
|
|
.mask_memory = agp_generic_mask_memory,
|
|
|
|
.masks = intel_generic_masks,
|
|
|
|
.agp_enable = agp_generic_enable,
|
|
|
|
.cache_flush = global_cache_flush,
|
|
|
|
.create_gatt_table = agp_generic_create_gatt_table,
|
|
|
|
.free_gatt_table = agp_generic_free_gatt_table,
|
|
|
|
.insert_memory = agp_generic_insert_memory,
|
|
|
|
.remove_memory = agp_generic_remove_memory,
|
|
|
|
.alloc_by_type = agp_generic_alloc_by_type,
|
|
|
|
.free_by_type = agp_generic_free_by_type,
|
|
|
|
.agp_alloc_page = agp_generic_alloc_page,
|
2008-08-21 02:46:11 +00:00
|
|
|
.agp_alloc_pages = agp_generic_alloc_pages,
|
2005-04-16 22:20:36 +00:00
|
|
|
.agp_destroy_page = agp_generic_destroy_page,
|
2008-08-21 02:46:17 +00:00
|
|
|
.agp_destroy_pages = agp_generic_destroy_pages,
|
2007-01-23 09:33:43 +00:00
|
|
|
.agp_type_to_mask_type = agp_generic_type_to_mask_type,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct agp_bridge_driver intel_810_driver = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.aperture_sizes = intel_i810_sizes,
|
|
|
|
.size_type = FIXED_APER_SIZE,
|
|
|
|
.num_aperture_sizes = 2,
|
2008-03-26 21:10:02 +00:00
|
|
|
.needs_scratch_page = true,
|
2005-04-16 22:20:36 +00:00
|
|
|
.configure = intel_i810_configure,
|
|
|
|
.fetch_size = intel_i810_fetch_size,
|
|
|
|
.cleanup = intel_i810_cleanup,
|
|
|
|
.tlb_flush = intel_i810_tlbflush,
|
|
|
|
.mask_memory = intel_i810_mask_memory,
|
|
|
|
.masks = intel_i810_masks,
|
|
|
|
.agp_enable = intel_i810_agp_enable,
|
|
|
|
.cache_flush = global_cache_flush,
|
|
|
|
.create_gatt_table = agp_generic_create_gatt_table,
|
|
|
|
.free_gatt_table = agp_generic_free_gatt_table,
|
|
|
|
.insert_memory = intel_i810_insert_entries,
|
|
|
|
.remove_memory = intel_i810_remove_entries,
|
|
|
|
.alloc_by_type = intel_i810_alloc_by_type,
|
|
|
|
.free_by_type = intel_i810_free_by_type,
|
|
|
|
.agp_alloc_page = agp_generic_alloc_page,
|
2008-08-21 02:46:11 +00:00
|
|
|
.agp_alloc_pages = agp_generic_alloc_pages,
|
2005-04-16 22:20:36 +00:00
|
|
|
.agp_destroy_page = agp_generic_destroy_page,
|
2008-08-21 02:46:17 +00:00
|
|
|
.agp_destroy_pages = agp_generic_destroy_pages,
|
2007-01-23 09:33:43 +00:00
|
|
|
.agp_type_to_mask_type = agp_generic_type_to_mask_type,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct agp_bridge_driver intel_815_driver = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.aperture_sizes = intel_815_sizes,
|
|
|
|
.size_type = U8_APER_SIZE,
|
|
|
|
.num_aperture_sizes = 2,
|
|
|
|
.configure = intel_815_configure,
|
|
|
|
.fetch_size = intel_815_fetch_size,
|
|
|
|
.cleanup = intel_8xx_cleanup,
|
|
|
|
.tlb_flush = intel_8xx_tlbflush,
|
|
|
|
.mask_memory = agp_generic_mask_memory,
|
|
|
|
.masks = intel_generic_masks,
|
|
|
|
.agp_enable = agp_generic_enable,
|
|
|
|
.cache_flush = global_cache_flush,
|
|
|
|
.create_gatt_table = agp_generic_create_gatt_table,
|
|
|
|
.free_gatt_table = agp_generic_free_gatt_table,
|
|
|
|
.insert_memory = agp_generic_insert_memory,
|
|
|
|
.remove_memory = agp_generic_remove_memory,
|
|
|
|
.alloc_by_type = agp_generic_alloc_by_type,
|
|
|
|
.free_by_type = agp_generic_free_by_type,
|
|
|
|
.agp_alloc_page = agp_generic_alloc_page,
|
2008-08-21 02:46:11 +00:00
|
|
|
.agp_alloc_pages = agp_generic_alloc_pages,
|
2005-04-16 22:20:36 +00:00
|
|
|
.agp_destroy_page = agp_generic_destroy_page,
|
2008-08-21 02:46:17 +00:00
|
|
|
.agp_destroy_pages = agp_generic_destroy_pages,
|
2008-06-19 04:27:53 +00:00
|
|
|
.agp_type_to_mask_type = agp_generic_type_to_mask_type,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct agp_bridge_driver intel_830_driver = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.aperture_sizes = intel_i830_sizes,
|
|
|
|
.size_type = FIXED_APER_SIZE,
|
2006-09-06 15:59:35 +00:00
|
|
|
.num_aperture_sizes = 4,
|
2008-03-26 21:10:02 +00:00
|
|
|
.needs_scratch_page = true,
|
2005-04-16 22:20:36 +00:00
|
|
|
.configure = intel_i830_configure,
|
|
|
|
.fetch_size = intel_i830_fetch_size,
|
|
|
|
.cleanup = intel_i830_cleanup,
|
|
|
|
.tlb_flush = intel_i810_tlbflush,
|
|
|
|
.mask_memory = intel_i810_mask_memory,
|
|
|
|
.masks = intel_i810_masks,
|
|
|
|
.agp_enable = intel_i810_agp_enable,
|
|
|
|
.cache_flush = global_cache_flush,
|
|
|
|
.create_gatt_table = intel_i830_create_gatt_table,
|
|
|
|
.free_gatt_table = intel_i830_free_gatt_table,
|
|
|
|
.insert_memory = intel_i830_insert_entries,
|
|
|
|
.remove_memory = intel_i830_remove_entries,
|
|
|
|
.alloc_by_type = intel_i830_alloc_by_type,
|
|
|
|
.free_by_type = intel_i810_free_by_type,
|
|
|
|
.agp_alloc_page = agp_generic_alloc_page,
|
2008-08-21 02:46:11 +00:00
|
|
|
.agp_alloc_pages = agp_generic_alloc_pages,
|
2005-04-16 22:20:36 +00:00
|
|
|
.agp_destroy_page = agp_generic_destroy_page,
|
2008-08-21 02:46:17 +00:00
|
|
|
.agp_destroy_pages = agp_generic_destroy_pages,
|
2007-01-23 09:33:43 +00:00
|
|
|
.agp_type_to_mask_type = intel_i830_type_to_mask_type,
|
2007-11-21 06:36:31 +00:00
|
|
|
.chipset_flush = intel_i830_chipset_flush,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct agp_bridge_driver intel_820_driver = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.aperture_sizes = intel_8xx_sizes,
|
|
|
|
.size_type = U8_APER_SIZE,
|
|
|
|
.num_aperture_sizes = 7,
|
|
|
|
.configure = intel_820_configure,
|
|
|
|
.fetch_size = intel_8xx_fetch_size,
|
|
|
|
.cleanup = intel_820_cleanup,
|
|
|
|
.tlb_flush = intel_820_tlbflush,
|
|
|
|
.mask_memory = agp_generic_mask_memory,
|
|
|
|
.masks = intel_generic_masks,
|
|
|
|
.agp_enable = agp_generic_enable,
|
|
|
|
.cache_flush = global_cache_flush,
|
|
|
|
.create_gatt_table = agp_generic_create_gatt_table,
|
|
|
|
.free_gatt_table = agp_generic_free_gatt_table,
|
|
|
|
.insert_memory = agp_generic_insert_memory,
|
|
|
|
.remove_memory = agp_generic_remove_memory,
|
|
|
|
.alloc_by_type = agp_generic_alloc_by_type,
|
|
|
|
.free_by_type = agp_generic_free_by_type,
|
|
|
|
.agp_alloc_page = agp_generic_alloc_page,
|
2008-08-21 02:46:11 +00:00
|
|
|
.agp_alloc_pages = agp_generic_alloc_pages,
|
2005-04-16 22:20:36 +00:00
|
|
|
.agp_destroy_page = agp_generic_destroy_page,
|
2008-08-21 02:46:17 +00:00
|
|
|
.agp_destroy_pages = agp_generic_destroy_pages,
|
2007-01-23 09:33:43 +00:00
|
|
|
.agp_type_to_mask_type = agp_generic_type_to_mask_type,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct agp_bridge_driver intel_830mp_driver = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.aperture_sizes = intel_830mp_sizes,
|
|
|
|
.size_type = U8_APER_SIZE,
|
|
|
|
.num_aperture_sizes = 4,
|
|
|
|
.configure = intel_830mp_configure,
|
|
|
|
.fetch_size = intel_8xx_fetch_size,
|
|
|
|
.cleanup = intel_8xx_cleanup,
|
|
|
|
.tlb_flush = intel_8xx_tlbflush,
|
|
|
|
.mask_memory = agp_generic_mask_memory,
|
|
|
|
.masks = intel_generic_masks,
|
|
|
|
.agp_enable = agp_generic_enable,
|
|
|
|
.cache_flush = global_cache_flush,
|
|
|
|
.create_gatt_table = agp_generic_create_gatt_table,
|
|
|
|
.free_gatt_table = agp_generic_free_gatt_table,
|
|
|
|
.insert_memory = agp_generic_insert_memory,
|
|
|
|
.remove_memory = agp_generic_remove_memory,
|
|
|
|
.alloc_by_type = agp_generic_alloc_by_type,
|
|
|
|
.free_by_type = agp_generic_free_by_type,
|
|
|
|
.agp_alloc_page = agp_generic_alloc_page,
|
2008-08-21 02:46:11 +00:00
|
|
|
.agp_alloc_pages = agp_generic_alloc_pages,
|
2005-04-16 22:20:36 +00:00
|
|
|
.agp_destroy_page = agp_generic_destroy_page,
|
2008-08-21 02:46:17 +00:00
|
|
|
.agp_destroy_pages = agp_generic_destroy_pages,
|
2007-01-23 09:33:43 +00:00
|
|
|
.agp_type_to_mask_type = agp_generic_type_to_mask_type,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct agp_bridge_driver intel_840_driver = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.aperture_sizes = intel_8xx_sizes,
|
|
|
|
.size_type = U8_APER_SIZE,
|
|
|
|
.num_aperture_sizes = 7,
|
|
|
|
.configure = intel_840_configure,
|
|
|
|
.fetch_size = intel_8xx_fetch_size,
|
|
|
|
.cleanup = intel_8xx_cleanup,
|
|
|
|
.tlb_flush = intel_8xx_tlbflush,
|
|
|
|
.mask_memory = agp_generic_mask_memory,
|
|
|
|
.masks = intel_generic_masks,
|
|
|
|
.agp_enable = agp_generic_enable,
|
|
|
|
.cache_flush = global_cache_flush,
|
|
|
|
.create_gatt_table = agp_generic_create_gatt_table,
|
|
|
|
.free_gatt_table = agp_generic_free_gatt_table,
|
|
|
|
.insert_memory = agp_generic_insert_memory,
|
|
|
|
.remove_memory = agp_generic_remove_memory,
|
|
|
|
.alloc_by_type = agp_generic_alloc_by_type,
|
|
|
|
.free_by_type = agp_generic_free_by_type,
|
|
|
|
.agp_alloc_page = agp_generic_alloc_page,
|
2008-08-21 02:46:11 +00:00
|
|
|
.agp_alloc_pages = agp_generic_alloc_pages,
|
2005-04-16 22:20:36 +00:00
|
|
|
.agp_destroy_page = agp_generic_destroy_page,
|
2008-08-21 02:46:17 +00:00
|
|
|
.agp_destroy_pages = agp_generic_destroy_pages,
|
2007-01-23 09:33:43 +00:00
|
|
|
.agp_type_to_mask_type = agp_generic_type_to_mask_type,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct agp_bridge_driver intel_845_driver = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.aperture_sizes = intel_8xx_sizes,
|
|
|
|
.size_type = U8_APER_SIZE,
|
|
|
|
.num_aperture_sizes = 7,
|
|
|
|
.configure = intel_845_configure,
|
|
|
|
.fetch_size = intel_8xx_fetch_size,
|
|
|
|
.cleanup = intel_8xx_cleanup,
|
|
|
|
.tlb_flush = intel_8xx_tlbflush,
|
|
|
|
.mask_memory = agp_generic_mask_memory,
|
|
|
|
.masks = intel_generic_masks,
|
|
|
|
.agp_enable = agp_generic_enable,
|
|
|
|
.cache_flush = global_cache_flush,
|
|
|
|
.create_gatt_table = agp_generic_create_gatt_table,
|
|
|
|
.free_gatt_table = agp_generic_free_gatt_table,
|
|
|
|
.insert_memory = agp_generic_insert_memory,
|
|
|
|
.remove_memory = agp_generic_remove_memory,
|
|
|
|
.alloc_by_type = agp_generic_alloc_by_type,
|
|
|
|
.free_by_type = agp_generic_free_by_type,
|
|
|
|
.agp_alloc_page = agp_generic_alloc_page,
|
2008-08-21 02:46:11 +00:00
|
|
|
.agp_alloc_pages = agp_generic_alloc_pages,
|
2005-04-16 22:20:36 +00:00
|
|
|
.agp_destroy_page = agp_generic_destroy_page,
|
2008-08-21 02:46:17 +00:00
|
|
|
.agp_destroy_pages = agp_generic_destroy_pages,
|
2007-01-23 09:33:43 +00:00
|
|
|
.agp_type_to_mask_type = agp_generic_type_to_mask_type,
|
2007-11-21 06:36:31 +00:00
|
|
|
.chipset_flush = intel_i830_chipset_flush,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct agp_bridge_driver intel_850_driver = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.aperture_sizes = intel_8xx_sizes,
|
|
|
|
.size_type = U8_APER_SIZE,
|
|
|
|
.num_aperture_sizes = 7,
|
|
|
|
.configure = intel_850_configure,
|
|
|
|
.fetch_size = intel_8xx_fetch_size,
|
|
|
|
.cleanup = intel_8xx_cleanup,
|
|
|
|
.tlb_flush = intel_8xx_tlbflush,
|
|
|
|
.mask_memory = agp_generic_mask_memory,
|
|
|
|
.masks = intel_generic_masks,
|
|
|
|
.agp_enable = agp_generic_enable,
|
|
|
|
.cache_flush = global_cache_flush,
|
|
|
|
.create_gatt_table = agp_generic_create_gatt_table,
|
|
|
|
.free_gatt_table = agp_generic_free_gatt_table,
|
|
|
|
.insert_memory = agp_generic_insert_memory,
|
|
|
|
.remove_memory = agp_generic_remove_memory,
|
|
|
|
.alloc_by_type = agp_generic_alloc_by_type,
|
|
|
|
.free_by_type = agp_generic_free_by_type,
|
|
|
|
.agp_alloc_page = agp_generic_alloc_page,
|
2008-08-21 02:46:11 +00:00
|
|
|
.agp_alloc_pages = agp_generic_alloc_pages,
|
2005-04-16 22:20:36 +00:00
|
|
|
.agp_destroy_page = agp_generic_destroy_page,
|
2008-08-21 02:46:17 +00:00
|
|
|
.agp_destroy_pages = agp_generic_destroy_pages,
|
2007-01-23 09:33:43 +00:00
|
|
|
.agp_type_to_mask_type = agp_generic_type_to_mask_type,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct agp_bridge_driver intel_860_driver = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.aperture_sizes = intel_8xx_sizes,
|
|
|
|
.size_type = U8_APER_SIZE,
|
|
|
|
.num_aperture_sizes = 7,
|
|
|
|
.configure = intel_860_configure,
|
|
|
|
.fetch_size = intel_8xx_fetch_size,
|
|
|
|
.cleanup = intel_8xx_cleanup,
|
|
|
|
.tlb_flush = intel_8xx_tlbflush,
|
|
|
|
.mask_memory = agp_generic_mask_memory,
|
|
|
|
.masks = intel_generic_masks,
|
|
|
|
.agp_enable = agp_generic_enable,
|
|
|
|
.cache_flush = global_cache_flush,
|
|
|
|
.create_gatt_table = agp_generic_create_gatt_table,
|
|
|
|
.free_gatt_table = agp_generic_free_gatt_table,
|
|
|
|
.insert_memory = agp_generic_insert_memory,
|
|
|
|
.remove_memory = agp_generic_remove_memory,
|
|
|
|
.alloc_by_type = agp_generic_alloc_by_type,
|
|
|
|
.free_by_type = agp_generic_free_by_type,
|
|
|
|
.agp_alloc_page = agp_generic_alloc_page,
|
2008-08-21 02:46:11 +00:00
|
|
|
.agp_alloc_pages = agp_generic_alloc_pages,
|
2005-04-16 22:20:36 +00:00
|
|
|
.agp_destroy_page = agp_generic_destroy_page,
|
2008-08-21 02:46:17 +00:00
|
|
|
.agp_destroy_pages = agp_generic_destroy_pages,
|
2007-01-23 09:33:43 +00:00
|
|
|
.agp_type_to_mask_type = agp_generic_type_to_mask_type,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct agp_bridge_driver intel_915_driver = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.aperture_sizes = intel_i830_sizes,
|
|
|
|
.size_type = FIXED_APER_SIZE,
|
2006-09-06 15:59:35 +00:00
|
|
|
.num_aperture_sizes = 4,
|
2008-03-26 21:10:02 +00:00
|
|
|
.needs_scratch_page = true,
|
2005-04-16 22:20:36 +00:00
|
|
|
.configure = intel_i915_configure,
|
2006-12-19 20:57:24 +00:00
|
|
|
.fetch_size = intel_i9xx_fetch_size,
|
2005-04-16 22:20:36 +00:00
|
|
|
.cleanup = intel_i915_cleanup,
|
|
|
|
.tlb_flush = intel_i810_tlbflush,
|
|
|
|
.mask_memory = intel_i810_mask_memory,
|
|
|
|
.masks = intel_i810_masks,
|
|
|
|
.agp_enable = intel_i810_agp_enable,
|
|
|
|
.cache_flush = global_cache_flush,
|
|
|
|
.create_gatt_table = intel_i915_create_gatt_table,
|
|
|
|
.free_gatt_table = intel_i830_free_gatt_table,
|
|
|
|
.insert_memory = intel_i915_insert_entries,
|
|
|
|
.remove_memory = intel_i915_remove_entries,
|
|
|
|
.alloc_by_type = intel_i830_alloc_by_type,
|
|
|
|
.free_by_type = intel_i810_free_by_type,
|
|
|
|
.agp_alloc_page = agp_generic_alloc_page,
|
2008-08-21 02:46:11 +00:00
|
|
|
.agp_alloc_pages = agp_generic_alloc_pages,
|
2005-04-16 22:20:36 +00:00
|
|
|
.agp_destroy_page = agp_generic_destroy_page,
|
2008-08-21 02:46:17 +00:00
|
|
|
.agp_destroy_pages = agp_generic_destroy_pages,
|
2007-01-23 09:33:43 +00:00
|
|
|
.agp_type_to_mask_type = intel_i830_type_to_mask_type,
|
2007-10-29 08:06:10 +00:00
|
|
|
.chipset_flush = intel_i915_chipset_flush,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct agp_bridge_driver intel_i965_driver = {
|
2008-06-19 04:27:53 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.aperture_sizes = intel_i830_sizes,
|
|
|
|
.size_type = FIXED_APER_SIZE,
|
|
|
|
.num_aperture_sizes = 4,
|
|
|
|
.needs_scratch_page = true,
|
2008-06-19 04:57:31 +00:00
|
|
|
.configure = intel_i915_configure,
|
|
|
|
.fetch_size = intel_i9xx_fetch_size,
|
2008-06-19 04:27:53 +00:00
|
|
|
.cleanup = intel_i915_cleanup,
|
|
|
|
.tlb_flush = intel_i810_tlbflush,
|
|
|
|
.mask_memory = intel_i965_mask_memory,
|
|
|
|
.masks = intel_i810_masks,
|
|
|
|
.agp_enable = intel_i810_agp_enable,
|
|
|
|
.cache_flush = global_cache_flush,
|
|
|
|
.create_gatt_table = intel_i965_create_gatt_table,
|
|
|
|
.free_gatt_table = intel_i830_free_gatt_table,
|
|
|
|
.insert_memory = intel_i915_insert_entries,
|
|
|
|
.remove_memory = intel_i915_remove_entries,
|
|
|
|
.alloc_by_type = intel_i830_alloc_by_type,
|
|
|
|
.free_by_type = intel_i810_free_by_type,
|
|
|
|
.agp_alloc_page = agp_generic_alloc_page,
|
2008-08-21 02:46:11 +00:00
|
|
|
.agp_alloc_pages = agp_generic_alloc_pages,
|
2008-06-19 04:27:53 +00:00
|
|
|
.agp_destroy_page = agp_generic_destroy_page,
|
2008-08-21 02:46:17 +00:00
|
|
|
.agp_destroy_pages = agp_generic_destroy_pages,
|
2008-06-19 04:27:53 +00:00
|
|
|
.agp_type_to_mask_type = intel_i830_type_to_mask_type,
|
2007-10-29 08:06:10 +00:00
|
|
|
.chipset_flush = intel_i915_chipset_flush,
|
2006-09-06 15:57:18 +00:00
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-02-22 23:41:28 +00:00
|
|
|
static const struct agp_bridge_driver intel_7505_driver = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.aperture_sizes = intel_8xx_sizes,
|
|
|
|
.size_type = U8_APER_SIZE,
|
|
|
|
.num_aperture_sizes = 7,
|
|
|
|
.configure = intel_7505_configure,
|
|
|
|
.fetch_size = intel_8xx_fetch_size,
|
|
|
|
.cleanup = intel_8xx_cleanup,
|
|
|
|
.tlb_flush = intel_8xx_tlbflush,
|
|
|
|
.mask_memory = agp_generic_mask_memory,
|
|
|
|
.masks = intel_generic_masks,
|
|
|
|
.agp_enable = agp_generic_enable,
|
|
|
|
.cache_flush = global_cache_flush,
|
|
|
|
.create_gatt_table = agp_generic_create_gatt_table,
|
|
|
|
.free_gatt_table = agp_generic_free_gatt_table,
|
|
|
|
.insert_memory = agp_generic_insert_memory,
|
|
|
|
.remove_memory = agp_generic_remove_memory,
|
|
|
|
.alloc_by_type = agp_generic_alloc_by_type,
|
|
|
|
.free_by_type = agp_generic_free_by_type,
|
|
|
|
.agp_alloc_page = agp_generic_alloc_page,
|
2008-08-21 02:46:11 +00:00
|
|
|
.agp_alloc_pages = agp_generic_alloc_pages,
|
2005-04-16 22:20:36 +00:00
|
|
|
.agp_destroy_page = agp_generic_destroy_page,
|
2008-08-21 02:46:17 +00:00
|
|
|
.agp_destroy_pages = agp_generic_destroy_pages,
|
2007-01-23 09:33:43 +00:00
|
|
|
.agp_type_to_mask_type = agp_generic_type_to_mask_type,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-06-06 03:16:25 +00:00
|
|
|
static const struct agp_bridge_driver intel_g33_driver = {
|
2008-06-19 04:27:53 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.aperture_sizes = intel_i830_sizes,
|
|
|
|
.size_type = FIXED_APER_SIZE,
|
|
|
|
.num_aperture_sizes = 4,
|
|
|
|
.needs_scratch_page = true,
|
|
|
|
.configure = intel_i915_configure,
|
|
|
|
.fetch_size = intel_i9xx_fetch_size,
|
|
|
|
.cleanup = intel_i915_cleanup,
|
|
|
|
.tlb_flush = intel_i810_tlbflush,
|
|
|
|
.mask_memory = intel_i965_mask_memory,
|
|
|
|
.masks = intel_i810_masks,
|
|
|
|
.agp_enable = intel_i810_agp_enable,
|
|
|
|
.cache_flush = global_cache_flush,
|
|
|
|
.create_gatt_table = intel_i915_create_gatt_table,
|
|
|
|
.free_gatt_table = intel_i830_free_gatt_table,
|
|
|
|
.insert_memory = intel_i915_insert_entries,
|
|
|
|
.remove_memory = intel_i915_remove_entries,
|
|
|
|
.alloc_by_type = intel_i830_alloc_by_type,
|
|
|
|
.free_by_type = intel_i810_free_by_type,
|
|
|
|
.agp_alloc_page = agp_generic_alloc_page,
|
2008-08-21 02:46:11 +00:00
|
|
|
.agp_alloc_pages = agp_generic_alloc_pages,
|
2008-06-19 04:27:53 +00:00
|
|
|
.agp_destroy_page = agp_generic_destroy_page,
|
2008-08-21 02:46:17 +00:00
|
|
|
.agp_destroy_pages = agp_generic_destroy_pages,
|
2008-06-19 04:27:53 +00:00
|
|
|
.agp_type_to_mask_type = intel_i830_type_to_mask_type,
|
2007-10-29 08:06:10 +00:00
|
|
|
.chipset_flush = intel_i915_chipset_flush,
|
2007-06-06 03:16:25 +00:00
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-30 01:45:58 +00:00
|
|
|
static int find_gmch(u16 device)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-05-30 01:45:58 +00:00
|
|
|
struct pci_dev *gmch_device;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-30 01:45:58 +00:00
|
|
|
gmch_device = pci_get_device(PCI_VENDOR_ID_INTEL, device, NULL);
|
|
|
|
if (gmch_device && PCI_FUNC(gmch_device->devfn) != 0) {
|
|
|
|
gmch_device = pci_get_device(PCI_VENDOR_ID_INTEL,
|
2008-01-25 01:23:04 +00:00
|
|
|
device, gmch_device);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-05-30 01:45:58 +00:00
|
|
|
if (!gmch_device)
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
|
2007-05-30 01:45:58 +00:00
|
|
|
intel_private.pcidev = gmch_device;
|
2005-04-16 22:20:36 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-05-30 01:45:58 +00:00
|
|
|
/* Table to describe Intel GMCH and AGP/PCIE GART drivers. At least one of
|
|
|
|
* driver and gmch_driver must be non-null, and find_gmch will determine
|
|
|
|
* which one should be used if a gmch_chip_id is present.
|
|
|
|
*/
|
|
|
|
static const struct intel_driver_description {
|
|
|
|
unsigned int chip_id;
|
|
|
|
unsigned int gmch_chip_id;
|
2007-06-14 02:01:04 +00:00
|
|
|
unsigned int multi_gmch_chip; /* if we have more gfx chip type on this HB. */
|
2007-05-30 01:45:58 +00:00
|
|
|
char *name;
|
|
|
|
const struct agp_bridge_driver *driver;
|
|
|
|
const struct agp_bridge_driver *gmch_driver;
|
|
|
|
} intel_agp_chipsets[] = {
|
2007-06-14 02:01:04 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82443LX_0, 0, 0, "440LX", &intel_generic_driver, NULL },
|
|
|
|
{ PCI_DEVICE_ID_INTEL_82443BX_0, 0, 0, "440BX", &intel_generic_driver, NULL },
|
|
|
|
{ PCI_DEVICE_ID_INTEL_82443GX_0, 0, 0, "440GX", &intel_generic_driver, NULL },
|
|
|
|
{ PCI_DEVICE_ID_INTEL_82810_MC1, PCI_DEVICE_ID_INTEL_82810_IG1, 0, "i810",
|
2007-05-30 01:45:58 +00:00
|
|
|
NULL, &intel_810_driver },
|
2007-06-14 02:01:04 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82810_MC3, PCI_DEVICE_ID_INTEL_82810_IG3, 0, "i810",
|
2007-05-30 01:45:58 +00:00
|
|
|
NULL, &intel_810_driver },
|
2007-06-14 02:01:04 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82810E_MC, PCI_DEVICE_ID_INTEL_82810E_IG, 0, "i810",
|
2007-05-30 01:45:58 +00:00
|
|
|
NULL, &intel_810_driver },
|
2007-06-14 02:01:04 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82815_MC, PCI_DEVICE_ID_INTEL_82815_CGC, 0, "i815",
|
|
|
|
&intel_815_driver, &intel_810_driver },
|
|
|
|
{ PCI_DEVICE_ID_INTEL_82820_HB, 0, 0, "i820", &intel_820_driver, NULL },
|
|
|
|
{ PCI_DEVICE_ID_INTEL_82820_UP_HB, 0, 0, "i820", &intel_820_driver, NULL },
|
|
|
|
{ PCI_DEVICE_ID_INTEL_82830_HB, PCI_DEVICE_ID_INTEL_82830_CGC, 0, "830M",
|
2007-05-30 01:45:58 +00:00
|
|
|
&intel_830mp_driver, &intel_830_driver },
|
2007-06-14 02:01:04 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82840_HB, 0, 0, "i840", &intel_840_driver, NULL },
|
|
|
|
{ PCI_DEVICE_ID_INTEL_82845_HB, 0, 0, "845G", &intel_845_driver, NULL },
|
|
|
|
{ PCI_DEVICE_ID_INTEL_82845G_HB, PCI_DEVICE_ID_INTEL_82845G_IG, 0, "830M",
|
2007-05-30 01:45:58 +00:00
|
|
|
&intel_845_driver, &intel_830_driver },
|
2007-06-14 02:01:04 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82850_HB, 0, 0, "i850", &intel_850_driver, NULL },
|
|
|
|
{ PCI_DEVICE_ID_INTEL_82855PM_HB, 0, 0, "855PM", &intel_845_driver, NULL },
|
|
|
|
{ PCI_DEVICE_ID_INTEL_82855GM_HB, PCI_DEVICE_ID_INTEL_82855GM_IG, 0, "855GM",
|
2007-05-30 01:45:58 +00:00
|
|
|
&intel_845_driver, &intel_830_driver },
|
2007-06-14 02:01:04 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82860_HB, 0, 0, "i860", &intel_860_driver, NULL },
|
|
|
|
{ PCI_DEVICE_ID_INTEL_82865_HB, PCI_DEVICE_ID_INTEL_82865_IG, 0, "865",
|
2007-05-30 01:45:58 +00:00
|
|
|
&intel_845_driver, &intel_830_driver },
|
2007-06-14 02:01:04 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82875_HB, 0, 0, "i875", &intel_845_driver, NULL },
|
2008-01-24 00:34:09 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_E7221_HB, PCI_DEVICE_ID_INTEL_E7221_IG, 0, "E7221 (i915)",
|
|
|
|
NULL, &intel_915_driver },
|
2007-06-14 02:01:04 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82915G_HB, PCI_DEVICE_ID_INTEL_82915G_IG, 0, "915G",
|
2007-06-21 05:43:18 +00:00
|
|
|
NULL, &intel_915_driver },
|
2007-06-14 02:01:04 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82915GM_HB, PCI_DEVICE_ID_INTEL_82915GM_IG, 0, "915GM",
|
2007-06-21 05:43:18 +00:00
|
|
|
NULL, &intel_915_driver },
|
2007-06-14 02:01:04 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82945G_HB, PCI_DEVICE_ID_INTEL_82945G_IG, 0, "945G",
|
2007-06-21 05:43:18 +00:00
|
|
|
NULL, &intel_915_driver },
|
2007-07-26 01:18:09 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82945GM_HB, PCI_DEVICE_ID_INTEL_82945GM_IG, 0, "945GM",
|
2007-06-21 05:43:18 +00:00
|
|
|
NULL, &intel_915_driver },
|
2007-07-26 01:18:09 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82945GME_HB, PCI_DEVICE_ID_INTEL_82945GME_IG, 0, "945GME",
|
2007-06-21 05:43:18 +00:00
|
|
|
NULL, &intel_915_driver },
|
2007-06-14 02:01:04 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82946GZ_HB, PCI_DEVICE_ID_INTEL_82946GZ_IG, 0, "946GZ",
|
2007-06-21 05:43:18 +00:00
|
|
|
NULL, &intel_i965_driver },
|
2008-01-23 05:49:26 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82G35_HB, PCI_DEVICE_ID_INTEL_82G35_IG, 0, "G35",
|
2007-06-21 05:43:18 +00:00
|
|
|
NULL, &intel_i965_driver },
|
2007-06-14 02:01:04 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82965Q_HB, PCI_DEVICE_ID_INTEL_82965Q_IG, 0, "965Q",
|
2007-06-21 05:43:18 +00:00
|
|
|
NULL, &intel_i965_driver },
|
2007-06-14 02:01:04 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82965G_HB, PCI_DEVICE_ID_INTEL_82965G_IG, 0, "965G",
|
2007-06-21 05:43:18 +00:00
|
|
|
NULL, &intel_i965_driver },
|
2007-07-26 01:18:09 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82965GM_HB, PCI_DEVICE_ID_INTEL_82965GM_IG, 0, "965GM",
|
2007-06-21 05:43:18 +00:00
|
|
|
NULL, &intel_i965_driver },
|
2007-07-26 01:18:09 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_82965GME_HB, PCI_DEVICE_ID_INTEL_82965GME_IG, 0, "965GME/GLE",
|
2007-06-21 05:43:18 +00:00
|
|
|
NULL, &intel_i965_driver },
|
2007-06-14 02:01:04 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_7505_0, 0, 0, "E7505", &intel_7505_driver, NULL },
|
|
|
|
{ PCI_DEVICE_ID_INTEL_7205_0, 0, 0, "E7205", &intel_7505_driver, NULL },
|
|
|
|
{ PCI_DEVICE_ID_INTEL_G33_HB, PCI_DEVICE_ID_INTEL_G33_IG, 0, "G33",
|
2007-06-21 05:43:18 +00:00
|
|
|
NULL, &intel_g33_driver },
|
2007-06-14 02:01:04 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_Q35_HB, PCI_DEVICE_ID_INTEL_Q35_IG, 0, "Q35",
|
2007-06-21 05:43:18 +00:00
|
|
|
NULL, &intel_g33_driver },
|
2007-06-14 02:01:04 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_Q33_HB, PCI_DEVICE_ID_INTEL_Q33_IG, 0, "Q33",
|
2007-06-21 05:43:18 +00:00
|
|
|
NULL, &intel_g33_driver },
|
2008-07-30 19:26:50 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_GM45_HB, PCI_DEVICE_ID_INTEL_GM45_IG, 0,
|
2008-12-23 02:56:27 +00:00
|
|
|
"Mobile Intel® GM45 Express", NULL, &intel_i965_driver },
|
2008-06-19 04:17:58 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_IGD_E_HB, PCI_DEVICE_ID_INTEL_IGD_E_IG, 0,
|
|
|
|
"Intel Integrated Graphics Device", NULL, &intel_i965_driver },
|
|
|
|
{ PCI_DEVICE_ID_INTEL_Q45_HB, PCI_DEVICE_ID_INTEL_Q45_IG, 0,
|
|
|
|
"Q45/Q43", NULL, &intel_i965_driver },
|
|
|
|
{ PCI_DEVICE_ID_INTEL_G45_HB, PCI_DEVICE_ID_INTEL_G45_IG, 0,
|
|
|
|
"G45/G43", NULL, &intel_i965_driver },
|
2008-11-17 06:39:00 +00:00
|
|
|
{ PCI_DEVICE_ID_INTEL_G41_HB, PCI_DEVICE_ID_INTEL_G41_IG, 0,
|
|
|
|
"G41", NULL, &intel_i965_driver },
|
2007-06-14 02:01:04 +00:00
|
|
|
{ 0, 0, 0, NULL, NULL, NULL }
|
2007-05-30 01:45:58 +00:00
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int __devinit agp_intel_probe(struct pci_dev *pdev,
|
|
|
|
const struct pci_device_id *ent)
|
|
|
|
{
|
|
|
|
struct agp_bridge_data *bridge;
|
|
|
|
u8 cap_ptr = 0;
|
|
|
|
struct resource *r;
|
2007-05-30 01:45:58 +00:00
|
|
|
int i;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
cap_ptr = pci_find_capability(pdev, PCI_CAP_ID_AGP);
|
|
|
|
|
|
|
|
bridge = agp_alloc_bridge();
|
|
|
|
if (!bridge)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-05-30 01:45:58 +00:00
|
|
|
for (i = 0; intel_agp_chipsets[i].name != NULL; i++) {
|
|
|
|
/* In case that multiple models of gfx chip may
|
|
|
|
stand on same host bridge type, this can be
|
|
|
|
sure we detect the right IGD. */
|
2007-06-14 02:01:04 +00:00
|
|
|
if (pdev->device == intel_agp_chipsets[i].chip_id) {
|
|
|
|
if ((intel_agp_chipsets[i].gmch_chip_id != 0) &&
|
|
|
|
find_gmch(intel_agp_chipsets[i].gmch_chip_id)) {
|
|
|
|
bridge->driver =
|
|
|
|
intel_agp_chipsets[i].gmch_driver;
|
|
|
|
break;
|
|
|
|
} else if (intel_agp_chipsets[i].multi_gmch_chip) {
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
bridge->driver = intel_agp_chipsets[i].driver;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2007-05-30 01:45:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (intel_agp_chipsets[i].name == NULL) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if (cap_ptr)
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_warn(&pdev->dev, "unsupported Intel chipset [%04x/%04x]\n",
|
|
|
|
pdev->vendor, pdev->device);
|
2007-05-30 01:45:58 +00:00
|
|
|
agp_put_bridge(bridge);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bridge->driver == NULL) {
|
2007-06-21 05:43:18 +00:00
|
|
|
/* bridge has no AGP and no IGD detected */
|
|
|
|
if (cap_ptr)
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_warn(&pdev->dev, "can't find bridge device (chip_id: %04x)\n",
|
|
|
|
intel_agp_chipsets[i].gmch_chip_id);
|
2005-04-16 22:20:36 +00:00
|
|
|
agp_put_bridge(bridge);
|
|
|
|
return -ENODEV;
|
2008-01-25 01:23:04 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
bridge->dev = pdev;
|
|
|
|
bridge->capndx = cap_ptr;
|
2007-05-30 01:40:46 +00:00
|
|
|
bridge->dev_private_data = &intel_private;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_info(&pdev->dev, "Intel %s Chipset\n", intel_agp_chipsets[i].name);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The following fixes the case where the BIOS has "forgotten" to
|
|
|
|
* provide an address range for the GART.
|
|
|
|
* 20030610 - hamish@zot.org
|
|
|
|
*/
|
|
|
|
r = &pdev->resource[0];
|
|
|
|
if (!r->start && r->end) {
|
2006-02-28 05:54:25 +00:00
|
|
|
if (pci_assign_resource(pdev, 0)) {
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_err(&pdev->dev, "can't assign resource 0\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
agp_put_bridge(bridge);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the device has not been properly setup, the following will catch
|
|
|
|
* the problem and should stop the system from crashing.
|
|
|
|
* 20030610 - hamish@zot.org
|
|
|
|
*/
|
|
|
|
if (pci_enable_device(pdev)) {
|
2008-07-30 19:26:51 +00:00
|
|
|
dev_err(&pdev->dev, "can't enable PCI device\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
agp_put_bridge(bridge);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fill in the mode register */
|
|
|
|
if (cap_ptr) {
|
|
|
|
pci_read_config_dword(pdev,
|
|
|
|
bridge->capndx+PCI_AGP_STATUS,
|
|
|
|
&bridge->mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
pci_set_drvdata(pdev, bridge);
|
|
|
|
return agp_add_bridge(bridge);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __devexit agp_intel_remove(struct pci_dev *pdev)
|
|
|
|
{
|
|
|
|
struct agp_bridge_data *bridge = pci_get_drvdata(pdev);
|
|
|
|
|
|
|
|
agp_remove_bridge(bridge);
|
|
|
|
|
2007-05-30 01:40:46 +00:00
|
|
|
if (intel_private.pcidev)
|
|
|
|
pci_dev_put(intel_private.pcidev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
agp_put_bridge(bridge);
|
|
|
|
}
|
|
|
|
|
2006-08-11 22:02:02 +00:00
|
|
|
#ifdef CONFIG_PM
|
2005-04-16 22:20:36 +00:00
|
|
|
static int agp_intel_resume(struct pci_dev *pdev)
|
|
|
|
{
|
|
|
|
struct agp_bridge_data *bridge = pci_get_drvdata(pdev);
|
2008-07-31 05:48:07 +00:00
|
|
|
int ret_val;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
pci_restore_state(pdev);
|
|
|
|
|
2007-01-17 03:07:54 +00:00
|
|
|
/* We should restore our graphics device's config space,
|
|
|
|
* as host bridge (00:00) resumes before graphics device (02:00),
|
|
|
|
* then our access to its pci space can work right.
|
|
|
|
*/
|
2007-05-30 01:40:46 +00:00
|
|
|
if (intel_private.pcidev)
|
|
|
|
pci_restore_state(intel_private.pcidev);
|
2007-01-17 03:07:54 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (bridge->driver == &intel_generic_driver)
|
|
|
|
intel_configure();
|
|
|
|
else if (bridge->driver == &intel_850_driver)
|
|
|
|
intel_850_configure();
|
|
|
|
else if (bridge->driver == &intel_845_driver)
|
|
|
|
intel_845_configure();
|
|
|
|
else if (bridge->driver == &intel_830mp_driver)
|
|
|
|
intel_830mp_configure();
|
|
|
|
else if (bridge->driver == &intel_915_driver)
|
|
|
|
intel_i915_configure();
|
|
|
|
else if (bridge->driver == &intel_830_driver)
|
|
|
|
intel_i830_configure();
|
|
|
|
else if (bridge->driver == &intel_810_driver)
|
|
|
|
intel_i810_configure();
|
2006-09-11 01:09:26 +00:00
|
|
|
else if (bridge->driver == &intel_i965_driver)
|
|
|
|
intel_i915_configure();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-31 05:48:07 +00:00
|
|
|
ret_val = agp_rebind_memory();
|
|
|
|
if (ret_val != 0)
|
|
|
|
return ret_val;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2006-08-11 22:02:02 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static struct pci_device_id agp_intel_pci_table[] = {
|
|
|
|
#define ID(x) \
|
|
|
|
{ \
|
|
|
|
.class = (PCI_CLASS_BRIDGE_HOST << 8), \
|
|
|
|
.class_mask = ~0, \
|
|
|
|
.vendor = PCI_VENDOR_ID_INTEL, \
|
|
|
|
.device = x, \
|
|
|
|
.subvendor = PCI_ANY_ID, \
|
|
|
|
.subdevice = PCI_ANY_ID, \
|
|
|
|
}
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82443LX_0),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82443BX_0),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82443GX_0),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82810_MC1),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82810_MC3),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82810E_MC),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82815_MC),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82820_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82820_UP_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82830_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82840_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82845_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82845G_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82850_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82855PM_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82855GM_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82860_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82865_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82875_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_7505_0),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_7205_0),
|
2008-01-24 00:34:09 +00:00
|
|
|
ID(PCI_DEVICE_ID_INTEL_E7221_HB),
|
2005-04-16 22:20:36 +00:00
|
|
|
ID(PCI_DEVICE_ID_INTEL_82915G_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82915GM_HB),
|
2005-05-31 18:50:49 +00:00
|
|
|
ID(PCI_DEVICE_ID_INTEL_82945G_HB),
|
2006-01-19 14:08:40 +00:00
|
|
|
ID(PCI_DEVICE_ID_INTEL_82945GM_HB),
|
2007-07-26 01:18:09 +00:00
|
|
|
ID(PCI_DEVICE_ID_INTEL_82945GME_HB),
|
2006-09-06 15:57:18 +00:00
|
|
|
ID(PCI_DEVICE_ID_INTEL_82946GZ_HB),
|
2008-01-23 05:49:26 +00:00
|
|
|
ID(PCI_DEVICE_ID_INTEL_82G35_HB),
|
2006-09-06 15:57:18 +00:00
|
|
|
ID(PCI_DEVICE_ID_INTEL_82965Q_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_82965G_HB),
|
2007-04-09 00:51:36 +00:00
|
|
|
ID(PCI_DEVICE_ID_INTEL_82965GM_HB),
|
2007-07-26 01:18:09 +00:00
|
|
|
ID(PCI_DEVICE_ID_INTEL_82965GME_HB),
|
2007-06-06 03:16:25 +00:00
|
|
|
ID(PCI_DEVICE_ID_INTEL_G33_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_Q35_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_Q33_HB),
|
2008-07-30 19:26:50 +00:00
|
|
|
ID(PCI_DEVICE_ID_INTEL_GM45_HB),
|
2008-06-19 04:17:58 +00:00
|
|
|
ID(PCI_DEVICE_ID_INTEL_IGD_E_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_Q45_HB),
|
|
|
|
ID(PCI_DEVICE_ID_INTEL_G45_HB),
|
2008-11-17 06:39:00 +00:00
|
|
|
ID(PCI_DEVICE_ID_INTEL_G41_HB),
|
2005-04-16 22:20:36 +00:00
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
|
|
|
MODULE_DEVICE_TABLE(pci, agp_intel_pci_table);
|
|
|
|
|
|
|
|
static struct pci_driver agp_intel_pci_driver = {
|
|
|
|
.name = "agpgart-intel",
|
|
|
|
.id_table = agp_intel_pci_table,
|
|
|
|
.probe = agp_intel_probe,
|
|
|
|
.remove = __devexit_p(agp_intel_remove),
|
2006-08-11 22:02:02 +00:00
|
|
|
#ifdef CONFIG_PM
|
2005-04-16 22:20:36 +00:00
|
|
|
.resume = agp_intel_resume,
|
2006-08-11 22:02:02 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static int __init agp_intel_init(void)
|
|
|
|
{
|
|
|
|
if (agp_off)
|
|
|
|
return -EINVAL;
|
|
|
|
return pci_register_driver(&agp_intel_pci_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit agp_intel_cleanup(void)
|
|
|
|
{
|
|
|
|
pci_unregister_driver(&agp_intel_pci_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(agp_intel_init);
|
|
|
|
module_exit(agp_intel_cleanup);
|
|
|
|
|
2008-10-20 17:31:45 +00:00
|
|
|
MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
|
2005-04-16 22:20:36 +00:00
|
|
|
MODULE_LICENSE("GPL and additional rights");
|