Attachment #49238 for bug #75251




/*-
 * Copyright (c) 2004 Eric Anholt
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * Based on reading the Linux 2.6.8.1 driver by Dave Jones.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include "opt_bus.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/bus.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#include <sys/proc.h>

#include <dev/pci/pcivar.h>
#include <dev/pci/pcireg.h>
#include <pci/agppriv.h>
#include <pci/agpreg.h>

#include <vm/vm.h>
#include <vm/vm_object.h>
#include <vm/pmap.h>
#include <machine/bus.h>
#include <machine/resource.h>
#include <sys/rman.h>

MALLOC_DECLARE(M_AGP);

#define READ4(off)	bus_space_read_4(sc->bst, sc->bsh, off)
#define WRITE4(off,v)	bus_space_write_4(sc->bst, sc->bsh, off, v)

struct agp_ati_softc {
	struct agp_softc agp;
	struct resource *regs;	/* memory mapped control registers */
	bus_space_tag_t bst;	/* bus_space tag */
	bus_space_handle_t bsh;	/* bus_space handle */
	u_int32_t	initial_aperture; /* aperture size at startup */
	char		is_rs300;

	/* The GATT */
	u_int32_t	ag_entries;
	u_int32_t      *ag_virtual;	/* virtual address of gatt */
	u_int32_t      *ag_vdir;	/* virtual address of page dir */
	vm_offset_t	ag_pdir;	/* physical address of page dir */
};


static const char*
agp_ati_match(device_t dev)
{
	if (pci_get_class(dev) != PCIC_BRIDGE
	    || pci_get_subclass(dev) != PCIS_BRIDGE_HOST)
		return NULL;

	if (agp_find_caps(dev) == 0)
		return NULL;

	switch (pci_get_devid(dev)) {
	case 0xcab01002:
		return ("ATI RS100 AGP bridge");
	case 0xcab21002:
		return ("ATI RS200 AGP bridge");
	case 0xcab31002:
		return ("ATI RS250 AGP bridge");
	case 0x58301002:
		return ("ATI RS300_100 AGP bridge");
	case 0x58311002:
		return ("ATI RS300_133 AGP bridge");
	case 0x58321002:
		return ("ATI RS300_166 AGP bridge");
	case 0x58331002:
		return ("ATI RS300_200 AGP bridge");
	};

	return NULL;
}

static int
agp_ati_probe(device_t dev)
{
	const char *desc;

	desc = agp_ati_match(dev);
	if (desc) {
		device_verbose(dev);
		device_set_desc(dev, desc);
		return 0;
	}

	return ENXIO;
}

static int
agp_ati_alloc_gatt(device_t dev)
{
	struct agp_ati_softc *sc = device_get_softc(dev);
	u_int32_t apsize = AGP_GET_APERTURE(dev);
	u_int32_t entries = apsize >> AGP_PAGE_SHIFT;
	int i;

	/* Alloc the GATT -- pointers to pages of AGP memory */
	sc->ag_entries = entries;
	sc->ag_virtual = malloc(entries * sizeof(u_int32_t), M_AGP,
	    M_NOWAIT | M_ZERO);
	if (sc->ag_virtual == NULL) {
		if (bootverbose)
			device_printf(dev, "aperture allocation failed\n");
		return ENOMEM;
	}

	/* Alloc the page directory -- pointers to each page of the GATT */
	sc->ag_vdir = malloc(AGP_PAGE_SIZE, M_AGP, M_NOWAIT | M_ZERO);
	if (sc->ag_vdir == NULL) {
		if (bootverbose)
			device_printf(dev, "pagedir allocation failed\n");
		free(sc->ag_virtual, M_AGP);
		return ENOMEM;
	}
	sc->ag_pdir = vtophys((vm_offset_t)sc->ag_vdir);

	/* Fill in the pagedir's pointers to GATT pages */
	for (i = 0; i < sc->ag_entries / 1024; i++) {
		vm_offset_t va;
		vm_offset_t pa;

		va = ((vm_offset_t)sc->ag_virtual) + i * AGP_PAGE_SIZE;
		pa = vtophys(va);
		sc->ag_vdir[i] = pa | 1;
	}

	/*
	 * Make sure the chipset can see everything.
	 */
	agp_flush_cache();

	return 0;
}


static int
agp_ati_attach(device_t dev)
{
	struct agp_ati_softc *sc = device_get_softc(dev);
	int error, rid;
	u_int32_t temp;
	u_int32_t apsize_reg, agpmode_reg;

	error = agp_generic_attach(dev);
	if (error)
		return error;

	switch (pci_get_devid(dev)) {
	case 0xcab01002: /* ATI RS100 AGP bridge */
	case 0xcab21002: /*ATI RS200 AGP bridge  */
	case 0xcab31002: /* ATI RS250 AGP bridge */
		sc->is_rs300 = 0;
		apsize_reg = ATI_RS100_APSIZE;
		agpmode_reg = ATI_RS100_IG_AGPMODE;
		break;
	case 0x58301002: /* ATI RS300_100 AGP bridge */
	case 0x58311002: /* ATI RS300_133 AGP bridge */
	case 0x58321002: /* ATI RS300_166 AGP bridge */
	case 0x58331002: /* ATI RS300_200 AGP bridge */
		sc->is_rs300 = 1;
		apsize_reg = ATI_RS300_APSIZE;
		agpmode_reg = ATI_RS300_IG_AGPMODE;
		break;
	default:
		/* Unknown chipset */
		return EINVAL;
	};

	rid = ATI_GART_MMADDR;
	sc->regs = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, RF_ACTIVE);
	if (!sc->regs) {
		agp_generic_detach(dev);
		return ENOMEM;
	}

	sc->bst = rman_get_bustag(sc->regs);
	sc->bsh = rman_get_bushandle(sc->regs);

	sc->initial_aperture = AGP_GET_APERTURE(dev);

	for (;;) {
		if (agp_ati_alloc_gatt(dev) == 0)
			break;

		/*
		 * Probably contigmalloc failure. Try reducing the
		 * aperture so that the gatt size reduces.
		 */
		if (AGP_SET_APERTURE(dev, AGP_GET_APERTURE(dev) / 2))
			return ENOMEM;
	}

	temp = pci_read_config(dev, apsize_reg, 4);
	pci_write_config(dev, apsize_reg, temp | 1, 4);

	pci_write_config(dev, agpmode_reg, 0x20000, 4);

	WRITE4(ATI_GART_FEATURE_ID, 0x00060000);

	temp = pci_read_config(dev, 4, 4);	/* XXX: Magic reg# */
	pci_write_config(dev, 4, temp | (1 << 14), 4);

	WRITE4(ATI_GART_BASE, sc->ag_pdir);

	AGP_FLUSH_TLB(dev);

	return 0;
}

static int
agp_ati_detach(device_t dev)
{
	struct agp_ati_softc *sc = device_get_softc(dev);
	int error;
	u_int32_t apsize_reg, temp;
	
	if (sc->is_rs300)
		apsize_reg = ATI_RS300_APSIZE;
	else
		apsize_reg = ATI_RS100_APSIZE;

	error = agp_generic_detach(dev);
	if (error)
		return error;

	/* Clear the GATT base */
	WRITE4(ATI_GART_BASE, 0);

	/* Put the aperture back the way it started. */
	AGP_SET_APERTURE(dev, sc->initial_aperture);

	temp = pci_read_config(dev, apsize_reg, 4);
	pci_write_config(dev, apsize_reg, temp & ~1, 4);

	free(sc->ag_vdir, M_AGP);
	free(sc->ag_virtual, M_AGP);

	bus_release_resource(dev, SYS_RES_MEMORY, ATI_GART_MMADDR, sc->regs);

	return 0;
}

static u_int32_t
agp_ati_get_aperture(device_t dev)
{
	struct agp_ati_softc *sc = device_get_softc(dev);
	int size_value;
	
	if (sc->is_rs300)
		size_value = pci_read_config(dev, ATI_RS300_APSIZE, 4);
	else
		size_value = pci_read_config(dev, ATI_RS100_APSIZE, 4);

	size_value = (size_value & 0x0000000e) >> 1;
	size_value = (32 * 1024 * 1024) << size_value;

	return size_value;
}

static int
agp_ati_set_aperture(device_t dev, u_int32_t aperture)
{
	struct agp_ati_softc *sc = device_get_softc(dev);
	int size_value;
	u_int32_t apsize_reg;
	
	if (sc->is_rs300)
		apsize_reg = ATI_RS300_APSIZE;
	else
		apsize_reg = ATI_RS100_APSIZE;

	size_value = pci_read_config(dev, apsize_reg, 4);

	size_value &= ~0x0000000e;
	size_value |= (ffs(aperture / (32 * 1024 * 1024)) - 1) << 1;

	pci_write_config(dev, apsize_reg, size_value, 4);

	return 0;
}

static int
agp_ati_bind_page(device_t dev, int offset, vm_offset_t physical)
{
	struct agp_ati_softc *sc = device_get_softc(dev);

	if (offset < 0 || offset >= (sc->ag_entries << AGP_PAGE_SHIFT))
		return EINVAL;

	sc->ag_virtual[offset >> AGP_PAGE_SHIFT] = physical;

	return 0;
}

static int
agp_ati_unbind_page(device_t dev, int offset)
{
	struct agp_ati_softc *sc = device_get_softc(dev);

	if (offset < 0 || offset >= (sc->ag_entries << AGP_PAGE_SHIFT))
		return EINVAL;

	sc->ag_virtual[offset >> AGP_PAGE_SHIFT] = 0;
	return 0;
}

static void
agp_ati_flush_tlb(device_t dev)
{
	struct agp_ati_softc *sc = device_get_softc(dev);

	/* Set the cache invalidate bit and wait for the chipset to clear */
	WRITE4(ATI_GART_CACHE_CNTRL, 1);
}

static device_method_t agp_ati_methods[] = {
	/* Device interface */
	DEVMETHOD(device_probe,		agp_ati_probe),
	DEVMETHOD(device_attach,	agp_ati_attach),
	DEVMETHOD(device_detach,	agp_ati_detach),
	DEVMETHOD(device_shutdown,	bus_generic_shutdown),
	DEVMETHOD(device_suspend,	bus_generic_suspend),
	DEVMETHOD(device_resume,	bus_generic_resume),

	/* AGP interface */
	DEVMETHOD(agp_get_aperture,	agp_ati_get_aperture),
	DEVMETHOD(agp_set_aperture,	agp_ati_set_aperture),
	DEVMETHOD(agp_bind_page,	agp_ati_bind_page),
	DEVMETHOD(agp_unbind_page,	agp_ati_unbind_page),
	DEVMETHOD(agp_flush_tlb,	agp_ati_flush_tlb),
	DEVMETHOD(agp_enable,		agp_generic_enable),
	DEVMETHOD(agp_alloc_memory,	agp_generic_alloc_memory),
	DEVMETHOD(agp_free_memory,	agp_generic_free_memory),
	DEVMETHOD(agp_bind_memory,	agp_generic_bind_memory),
	DEVMETHOD(agp_unbind_memory,	agp_generic_unbind_memory),

	{ 0, 0 }
};

static driver_t agp_ati_driver = {
	"agp",
	agp_ati_methods,
	sizeof(struct agp_ati_softc),
};

static devclass_t agp_devclass;

DRIVER_MODULE(agp_ati, pci, agp_ati_driver, agp_devclass, 0, 0);
MODULE_DEPEND(agp_ati, agp, 1, 1, 1);
MODULE_DEPEND(agp_ati, pci, 1, 1, 1);




#define	AGP_AMD64_CACHECTRL_INVGART	0x00000001
#define	AGP_AMD64_CACHECTRL_PTEERR	0x00000002

/*
 * ATI IGP registers
 */
#define ATI_GART_MMADDR		0x14
#define ATI_RS100_APSIZE	0xac
#define ATI_RS100_IG_AGPMODE	0xb0
#define ATI_RS300_APSIZE	0xf8
#define ATI_RS300_IG_AGPMODE	0xfc
#define ATI_GART_FEATURE_ID	0x00
#define ATI_GART_BASE		0x04
#define ATI_GART_CACHE_CNTRL	0x0c

#endif /* !_PCI_AGPREG_H_ */

Return to bug 75251

Lines 262-265 Link Here

(-)agpreg.h (+12 lines)
262	#define AGP_AMD64_CACHECTRL_INVGART 0x00000001	262	#define AGP_AMD64_CACHECTRL_INVGART 0x00000001
263	#define AGP_AMD64_CACHECTRL_PTEERR 0x00000002	263	#define AGP_AMD64_CACHECTRL_PTEERR 0x00000002
264		264
		265	/*
		266	* ATI IGP registers
		267	*/
		268	#define ATI_GART_MMADDR 0x14
		269	#define ATI_RS100_APSIZE 0xac
		270	#define ATI_RS100_IG_AGPMODE 0xb0
		271	#define ATI_RS300_APSIZE 0xf8
		272	#define ATI_RS300_IG_AGPMODE 0xfc
		273	#define ATI_GART_FEATURE_ID 0x00
		274	#define ATI_GART_BASE 0x04
		275	#define ATI_GART_CACHE_CNTRL 0x0c
		276
265	#endif /* !_PCI_AGPREG_H_ */	277	#endif /* !_PCI_AGPREG_H_ */

Added Link Here

(-)agp_ati.c (+383 lines)
1	/*-
2	* Copyright (c) 2004 Eric Anholt
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24	* SUCH DAMAGE.
25	*
26	* Based on reading the Linux 2.6.8.1 driver by Dave Jones.
27	*/
28
29	#include <sys/cdefs.h>
30	__FBSDID("$FreeBSD$");
31
32	#include "opt_bus.h"
33
34	#include <sys/param.h>
35	#include <sys/systm.h>
36	#include <sys/malloc.h>
37	#include <sys/kernel.h>
38	#include <sys/module.h>
39	#include <sys/bus.h>
40	#include <sys/lock.h>
41	#include <sys/mutex.h>
42	#include <sys/proc.h>
43
44	#include <dev/pci/pcivar.h>
45	#include <dev/pci/pcireg.h>
46	#include <pci/agppriv.h>
47	#include <pci/agpreg.h>
48
49	#include <vm/vm.h>
50	#include <vm/vm_object.h>
51	#include <vm/pmap.h>
52	#include <machine/bus.h>
53	#include <machine/resource.h>
54	#include <sys/rman.h>
55
56	MALLOC_DECLARE(M_AGP);
57
58	#define READ4(off) bus_space_read_4(sc->bst, sc->bsh, off)
59	#define WRITE4(off,v) bus_space_write_4(sc->bst, sc->bsh, off, v)
60
61	struct agp_ati_softc {
62	struct agp_softc agp;
63	struct resource regs; / memory mapped control registers */
64	bus_space_tag_t bst; /* bus_space tag */
65	bus_space_handle_t bsh; /* bus_space handle */
66	u_int32_t initial_aperture; /* aperture size at startup */
67	char is_rs300;
68
69	/* The GATT */
70	u_int32_t ag_entries;
71	u_int32_t ag_virtual; / virtual address of gatt */
72	u_int32_t ag_vdir; / virtual address of page dir */
73	vm_offset_t ag_pdir; /* physical address of page dir */
74	};
75
76
77	static const char*
78	agp_ati_match(device_t dev)
79	{
80	if (pci_get_class(dev) != PCIC_BRIDGE
81	\|\| pci_get_subclass(dev) != PCIS_BRIDGE_HOST)
82	return NULL;
83
84	if (agp_find_caps(dev) == 0)
85	return NULL;
86
87	switch (pci_get_devid(dev)) {
88	case 0xcab01002:
89	return ("ATI RS100 AGP bridge");
90	case 0xcab21002:
91	return ("ATI RS200 AGP bridge");
92	case 0xcab31002:
93	return ("ATI RS250 AGP bridge");
94	case 0x58301002:
95	return ("ATI RS300_100 AGP bridge");
96	case 0x58311002:
97	return ("ATI RS300_133 AGP bridge");
98	case 0x58321002:
99	return ("ATI RS300_166 AGP bridge");
100	case 0x58331002:
101	return ("ATI RS300_200 AGP bridge");
102	};
103
104	return NULL;
105	}
106
107	static int
108	agp_ati_probe(device_t dev)
109	{
110	const char *desc;
111
112	desc = agp_ati_match(dev);
113	if (desc) {
114	device_verbose(dev);
115	device_set_desc(dev, desc);
116	return 0;
117	}
118
119	return ENXIO;
120	}
121
122	static int
123	agp_ati_alloc_gatt(device_t dev)
124	{
125	struct agp_ati_softc *sc = device_get_softc(dev);
126	u_int32_t apsize = AGP_GET_APERTURE(dev);
127	u_int32_t entries = apsize >> AGP_PAGE_SHIFT;
128	int i;
129
130	/* Alloc the GATT -- pointers to pages of AGP memory */
131	sc->ag_entries = entries;
132	sc->ag_virtual = malloc(entries * sizeof(u_int32_t), M_AGP,
133	M_NOWAIT \| M_ZERO);
134	if (sc->ag_virtual == NULL) {
135	if (bootverbose)
136	device_printf(dev, "aperture allocation failed\n");
137	return ENOMEM;
138	}
139
140	/* Alloc the page directory -- pointers to each page of the GATT */
141	sc->ag_vdir = malloc(AGP_PAGE_SIZE, M_AGP, M_NOWAIT \| M_ZERO);
142	if (sc->ag_vdir == NULL) {
143	if (bootverbose)
144	device_printf(dev, "pagedir allocation failed\n");
145	free(sc->ag_virtual, M_AGP);
146	return ENOMEM;
147	}
148	sc->ag_pdir = vtophys((vm_offset_t)sc->ag_vdir);
149
150	/* Fill in the pagedir's pointers to GATT pages */
151	for (i = 0; i < sc->ag_entries / 1024; i++) {
152	vm_offset_t va;
153	vm_offset_t pa;
154
155	va = ((vm_offset_t)sc->ag_virtual) + i * AGP_PAGE_SIZE;
156	pa = vtophys(va);
157	sc->ag_vdir[i] = pa \| 1;
158	}
159
160	/*
161	* Make sure the chipset can see everything.
162	*/
163	agp_flush_cache();
164
165	return 0;
166	}
167
168
169	static int
170	agp_ati_attach(device_t dev)
171	{
172	struct agp_ati_softc *sc = device_get_softc(dev);
173	int error, rid;
174	u_int32_t temp;
175	u_int32_t apsize_reg, agpmode_reg;
176
177	error = agp_generic_attach(dev);
178	if (error)
179	return error;
180
181	switch (pci_get_devid(dev)) {
182	case 0xcab01002: /* ATI RS100 AGP bridge */
183	case 0xcab21002: /ATI RS200 AGP bridge /
184	case 0xcab31002: /* ATI RS250 AGP bridge */
185	sc->is_rs300 = 0;
186	apsize_reg = ATI_RS100_APSIZE;
187	agpmode_reg = ATI_RS100_IG_AGPMODE;
188	break;
189	case 0x58301002: /* ATI RS300_100 AGP bridge */
190	case 0x58311002: /* ATI RS300_133 AGP bridge */
191	case 0x58321002: /* ATI RS300_166 AGP bridge */
192	case 0x58331002: /* ATI RS300_200 AGP bridge */
193	sc->is_rs300 = 1;
194	apsize_reg = ATI_RS300_APSIZE;
195	agpmode_reg = ATI_RS300_IG_AGPMODE;
196	break;
197	default:
198	/* Unknown chipset */
199	return EINVAL;
200	};
201
202	rid = ATI_GART_MMADDR;
203	sc->regs = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, RF_ACTIVE);
204	if (!sc->regs) {
205	agp_generic_detach(dev);
206	return ENOMEM;
207	}
208
209	sc->bst = rman_get_bustag(sc->regs);
210	sc->bsh = rman_get_bushandle(sc->regs);
211
212	sc->initial_aperture = AGP_GET_APERTURE(dev);
213
214	for (;;) {
215	if (agp_ati_alloc_gatt(dev) == 0)
216	break;
217
218	/*
219	* Probably contigmalloc failure. Try reducing the
220	* aperture so that the gatt size reduces.
221	*/
222	if (AGP_SET_APERTURE(dev, AGP_GET_APERTURE(dev) / 2))
223	return ENOMEM;
224	}
225
226	temp = pci_read_config(dev, apsize_reg, 4);
227	pci_write_config(dev, apsize_reg, temp \| 1, 4);
228
229	pci_write_config(dev, agpmode_reg, 0x20000, 4);
230
231	WRITE4(ATI_GART_FEATURE_ID, 0x00060000);
232
233	temp = pci_read_config(dev, 4, 4); /* XXX: Magic reg# */
234	pci_write_config(dev, 4, temp \| (1 << 14), 4);
235
236	WRITE4(ATI_GART_BASE, sc->ag_pdir);
237
238	AGP_FLUSH_TLB(dev);
239
240	return 0;
241	}
242
243	static int
244	agp_ati_detach(device_t dev)
245	{
246	struct agp_ati_softc *sc = device_get_softc(dev);
247	int error;
248	u_int32_t apsize_reg, temp;
249
250	if (sc->is_rs300)
251	apsize_reg = ATI_RS300_APSIZE;
252	else
253	apsize_reg = ATI_RS100_APSIZE;
254
255	error = agp_generic_detach(dev);
256	if (error)
257	return error;
258
259	/* Clear the GATT base */
260	WRITE4(ATI_GART_BASE, 0);
261
262	/* Put the aperture back the way it started. */
263	AGP_SET_APERTURE(dev, sc->initial_aperture);
264
265	temp = pci_read_config(dev, apsize_reg, 4);
266	pci_write_config(dev, apsize_reg, temp & ~1, 4);
267
268	free(sc->ag_vdir, M_AGP);
269	free(sc->ag_virtual, M_AGP);
270
271	bus_release_resource(dev, SYS_RES_MEMORY, ATI_GART_MMADDR, sc->regs);
272
273	return 0;
274	}
275
276	static u_int32_t
277	agp_ati_get_aperture(device_t dev)
278	{
279	struct agp_ati_softc *sc = device_get_softc(dev);
280	int size_value;
281
282	if (sc->is_rs300)
283	size_value = pci_read_config(dev, ATI_RS300_APSIZE, 4);
284	else
285	size_value = pci_read_config(dev, ATI_RS100_APSIZE, 4);
286
287	size_value = (size_value & 0x0000000e) >> 1;
288	size_value = (32 * 1024 * 1024) << size_value;
289
290	return size_value;
291	}
292
293	static int
294	agp_ati_set_aperture(device_t dev, u_int32_t aperture)
295	{
296	struct agp_ati_softc *sc = device_get_softc(dev);
297	int size_value;
298	u_int32_t apsize_reg;
299
300	if (sc->is_rs300)
301	apsize_reg = ATI_RS300_APSIZE;
302	else
303	apsize_reg = ATI_RS100_APSIZE;
304
305	size_value = pci_read_config(dev, apsize_reg, 4);
306
307	size_value &= ~0x0000000e;
308	size_value \|= (ffs(aperture / (32 * 1024 * 1024)) - 1) << 1;
309
310	pci_write_config(dev, apsize_reg, size_value, 4);
311
312	return 0;
313	}
314
315	static int
316	agp_ati_bind_page(device_t dev, int offset, vm_offset_t physical)
317	{
318	struct agp_ati_softc *sc = device_get_softc(dev);
319
320	if (offset < 0 \|\| offset >= (sc->ag_entries << AGP_PAGE_SHIFT))
321	return EINVAL;
322
323	sc->ag_virtual[offset >> AGP_PAGE_SHIFT] = physical;
324
325	return 0;
326	}
327
328	static int
329	agp_ati_unbind_page(device_t dev, int offset)
330	{
331	struct agp_ati_softc *sc = device_get_softc(dev);
332
333	if (offset < 0 \|\| offset >= (sc->ag_entries << AGP_PAGE_SHIFT))
334	return EINVAL;
335
336	sc->ag_virtual[offset >> AGP_PAGE_SHIFT] = 0;
337	return 0;
338	}
339
340	static void
341	agp_ati_flush_tlb(device_t dev)
342	{
343	struct agp_ati_softc *sc = device_get_softc(dev);
344
345	/* Set the cache invalidate bit and wait for the chipset to clear */
346	WRITE4(ATI_GART_CACHE_CNTRL, 1);
347	}
348
349	static device_method_t agp_ati_methods[] = {
350	/* Device interface */
351	DEVMETHOD(device_probe, agp_ati_probe),
352	DEVMETHOD(device_attach, agp_ati_attach),
353	DEVMETHOD(device_detach, agp_ati_detach),
354	DEVMETHOD(device_shutdown, bus_generic_shutdown),
355	DEVMETHOD(device_suspend, bus_generic_suspend),
356	DEVMETHOD(device_resume, bus_generic_resume),
357
358	/* AGP interface */
359	DEVMETHOD(agp_get_aperture, agp_ati_get_aperture),
360	DEVMETHOD(agp_set_aperture, agp_ati_set_aperture),
361	DEVMETHOD(agp_bind_page, agp_ati_bind_page),
362	DEVMETHOD(agp_unbind_page, agp_ati_unbind_page),
363	DEVMETHOD(agp_flush_tlb, agp_ati_flush_tlb),
364	DEVMETHOD(agp_enable, agp_generic_enable),
365	DEVMETHOD(agp_alloc_memory, agp_generic_alloc_memory),
366	DEVMETHOD(agp_free_memory, agp_generic_free_memory),
367	DEVMETHOD(agp_bind_memory, agp_generic_bind_memory),
368	DEVMETHOD(agp_unbind_memory, agp_generic_unbind_memory),
369
370	{ 0, 0 }
371	};
372
373	static driver_t agp_ati_driver = {
374	"agp",
375	agp_ati_methods,
376	sizeof(struct agp_ati_softc),
377	};
378
379	static devclass_t agp_devclass;
380
381	DRIVER_MODULE(agp_ati, pci, agp_ati_driver, agp_devclass, 0, 0);
382	MODULE_DEPEND(agp_ati, agp, 1, 1, 1);
383	MODULE_DEPEND(agp_ati, pci, 1, 1, 1);