159747216SDoug Rabson /*- 259747216SDoug Rabson * Copyright (c) 2000 Doug Rabson 359747216SDoug Rabson * All rights reserved. 459747216SDoug Rabson * 559747216SDoug Rabson * Redistribution and use in source and binary forms, with or without 659747216SDoug Rabson * modification, are permitted provided that the following conditions 759747216SDoug Rabson * are met: 859747216SDoug Rabson * 1. Redistributions of source code must retain the above copyright 959747216SDoug Rabson * notice, this list of conditions and the following disclaimer. 1059747216SDoug Rabson * 2. Redistributions in binary form must reproduce the above copyright 1159747216SDoug Rabson * notice, this list of conditions and the following disclaimer in the 1259747216SDoug Rabson * documentation and/or other materials provided with the distribution. 1359747216SDoug Rabson * 1459747216SDoug Rabson * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 1559747216SDoug Rabson * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1659747216SDoug Rabson * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1759747216SDoug Rabson * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 1859747216SDoug Rabson * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 1959747216SDoug Rabson * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2059747216SDoug Rabson * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2159747216SDoug Rabson * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2259747216SDoug Rabson * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2359747216SDoug Rabson * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2459747216SDoug Rabson * SUCH DAMAGE. 2559747216SDoug Rabson */ 2659747216SDoug Rabson 27f4636c59SDavid E. O'Brien #include <sys/cdefs.h> 28f4636c59SDavid E. O'Brien __FBSDID("$FreeBSD$"); 29f4636c59SDavid E. O'Brien 3059747216SDoug Rabson #include "opt_bus.h" 3159747216SDoug Rabson 3259747216SDoug Rabson #include <sys/param.h> 3359747216SDoug Rabson #include <sys/systm.h> 3459747216SDoug Rabson #include <sys/malloc.h> 3559747216SDoug Rabson #include <sys/kernel.h> 3659747216SDoug Rabson #include <sys/bus.h> 3759747216SDoug Rabson #include <sys/conf.h> 3859747216SDoug Rabson #include <sys/ioccom.h> 3959747216SDoug Rabson #include <sys/agpio.h> 4059747216SDoug Rabson #include <sys/lock.h> 417e9e7dc4SBruce Evans #include <sys/lockmgr.h> 4223955314SAlfred Perlstein #include <sys/mutex.h> 431639f08bSJohn Baldwin #include <sys/proc.h> 4459747216SDoug Rabson 4519b7ffd1SWarner Losh #include <dev/pci/pcivar.h> 4619b7ffd1SWarner Losh #include <dev/pci/pcireg.h> 4759747216SDoug Rabson #include <pci/agppriv.h> 4859747216SDoug Rabson #include <pci/agpvar.h> 4959747216SDoug Rabson #include <pci/agpreg.h> 5059747216SDoug Rabson 5159747216SDoug Rabson #include <vm/vm.h> 5259747216SDoug Rabson #include <vm/vm_object.h> 5359747216SDoug Rabson #include <vm/vm_page.h> 5459747216SDoug Rabson #include <vm/vm_pageout.h> 5559747216SDoug Rabson #include <vm/pmap.h> 5659747216SDoug Rabson 5759747216SDoug Rabson #include <machine/md_var.h> 5859747216SDoug Rabson #include <machine/bus.h> 5959747216SDoug Rabson #include <machine/resource.h> 6059747216SDoug Rabson #include <sys/rman.h> 6159747216SDoug Rabson 6259747216SDoug Rabson MODULE_VERSION(agp, 1); 6359747216SDoug Rabson 64315a1645SAssar Westerlund MALLOC_DEFINE(M_AGP, "agp", "AGP data structures"); 6559747216SDoug Rabson 6659747216SDoug Rabson #define CDEV_MAJOR 148 6759747216SDoug Rabson /* agp_drv.c */ 6859747216SDoug Rabson static d_open_t agp_open; 6959747216SDoug Rabson static d_close_t agp_close; 7059747216SDoug Rabson static d_ioctl_t agp_ioctl; 7159747216SDoug Rabson static d_mmap_t agp_mmap; 7259747216SDoug Rabson 7359747216SDoug Rabson static struct cdevsw agp_cdevsw = { 747ac40f5fSPoul-Henning Kamp .d_open = agp_open, 757ac40f5fSPoul-Henning Kamp .d_close = agp_close, 767ac40f5fSPoul-Henning Kamp .d_ioctl = agp_ioctl, 777ac40f5fSPoul-Henning Kamp .d_mmap = agp_mmap, 787ac40f5fSPoul-Henning Kamp .d_name = "agp", 797ac40f5fSPoul-Henning Kamp .d_maj = CDEV_MAJOR, 807ac40f5fSPoul-Henning Kamp .d_flags = D_TTY, 8159747216SDoug Rabson }; 8259747216SDoug Rabson 8359747216SDoug Rabson static devclass_t agp_devclass; 8459747216SDoug Rabson #define KDEV2DEV(kdev) devclass_get_device(agp_devclass, minor(kdev)) 8559747216SDoug Rabson 8659747216SDoug Rabson /* Helper functions for implementing chipset mini drivers. */ 8759747216SDoug Rabson 88111618cbSDoug Rabson void 89111618cbSDoug Rabson agp_flush_cache() 90111618cbSDoug Rabson { 9159747216SDoug Rabson #ifdef __i386__ 92111618cbSDoug Rabson wbinvd(); 9359747216SDoug Rabson #endif 9405d1e23aSEric Anholt #ifdef __alpha__ 9505d1e23aSEric Anholt /* FIXME: This is most likely not correct as it doesn't flush CPU 9605d1e23aSEric Anholt * write caches, but we don't have a facility to do that and 9705d1e23aSEric Anholt * this is all linux does, too */ 9805d1e23aSEric Anholt alpha_mb(); 9905d1e23aSEric Anholt #endif 100111618cbSDoug Rabson } 10159747216SDoug Rabson 10259747216SDoug Rabson u_int8_t 10359747216SDoug Rabson agp_find_caps(device_t dev) 10459747216SDoug Rabson { 10559747216SDoug Rabson u_int32_t status; 10659747216SDoug Rabson u_int8_t ptr, next; 10759747216SDoug Rabson 10859747216SDoug Rabson /* 10959747216SDoug Rabson * Check the CAP_LIST bit of the PCI status register first. 11059747216SDoug Rabson */ 11159747216SDoug Rabson status = pci_read_config(dev, PCIR_STATUS, 2); 11259747216SDoug Rabson if (!(status & 0x10)) 11359747216SDoug Rabson return 0; 11459747216SDoug Rabson 11559747216SDoug Rabson /* 11659747216SDoug Rabson * Traverse the capabilities list. 11759747216SDoug Rabson */ 11859747216SDoug Rabson for (ptr = pci_read_config(dev, AGP_CAPPTR, 1); 11959747216SDoug Rabson ptr != 0; 12059747216SDoug Rabson ptr = next) { 12159747216SDoug Rabson u_int32_t capid = pci_read_config(dev, ptr, 4); 12259747216SDoug Rabson next = AGP_CAPID_GET_NEXT_PTR(capid); 12359747216SDoug Rabson 12459747216SDoug Rabson /* 12559747216SDoug Rabson * If this capability entry ID is 2, then we are done. 12659747216SDoug Rabson */ 12759747216SDoug Rabson if (AGP_CAPID_GET_CAP_ID(capid) == 2) 12859747216SDoug Rabson return ptr; 12959747216SDoug Rabson } 13059747216SDoug Rabson 13159747216SDoug Rabson return 0; 13259747216SDoug Rabson } 13359747216SDoug Rabson 13459747216SDoug Rabson /* 13559747216SDoug Rabson * Find an AGP display device (if any). 13659747216SDoug Rabson */ 13759747216SDoug Rabson static device_t 13859747216SDoug Rabson agp_find_display(void) 13959747216SDoug Rabson { 14059747216SDoug Rabson devclass_t pci = devclass_find("pci"); 14159747216SDoug Rabson device_t bus, dev = 0; 14259747216SDoug Rabson device_t *kids; 14359747216SDoug Rabson int busnum, numkids, i; 14459747216SDoug Rabson 14559747216SDoug Rabson for (busnum = 0; busnum < devclass_get_maxunit(pci); busnum++) { 14659747216SDoug Rabson bus = devclass_get_device(pci, busnum); 14759747216SDoug Rabson if (!bus) 14859747216SDoug Rabson continue; 14959747216SDoug Rabson device_get_children(bus, &kids, &numkids); 15059747216SDoug Rabson for (i = 0; i < numkids; i++) { 15159747216SDoug Rabson dev = kids[i]; 15259747216SDoug Rabson if (pci_get_class(dev) == PCIC_DISPLAY 15359747216SDoug Rabson && pci_get_subclass(dev) == PCIS_DISPLAY_VGA) 15459747216SDoug Rabson if (agp_find_caps(dev)) { 15559747216SDoug Rabson free(kids, M_TEMP); 15659747216SDoug Rabson return dev; 15759747216SDoug Rabson } 15859747216SDoug Rabson 15959747216SDoug Rabson } 16059747216SDoug Rabson free(kids, M_TEMP); 16159747216SDoug Rabson } 16259747216SDoug Rabson 16359747216SDoug Rabson return 0; 16459747216SDoug Rabson } 16559747216SDoug Rabson 16659747216SDoug Rabson struct agp_gatt * 16759747216SDoug Rabson agp_alloc_gatt(device_t dev) 16859747216SDoug Rabson { 16959747216SDoug Rabson u_int32_t apsize = AGP_GET_APERTURE(dev); 17059747216SDoug Rabson u_int32_t entries = apsize >> AGP_PAGE_SHIFT; 17159747216SDoug Rabson struct agp_gatt *gatt; 17259747216SDoug Rabson 17359747216SDoug Rabson if (bootverbose) 17459747216SDoug Rabson device_printf(dev, 17559747216SDoug Rabson "allocating GATT for aperture of size %dM\n", 17659747216SDoug Rabson apsize / (1024*1024)); 17759747216SDoug Rabson 17859747216SDoug Rabson gatt = malloc(sizeof(struct agp_gatt), M_AGP, M_NOWAIT); 17959747216SDoug Rabson if (!gatt) 18059747216SDoug Rabson return 0; 18159747216SDoug Rabson 18259747216SDoug Rabson gatt->ag_entries = entries; 18359747216SDoug Rabson gatt->ag_virtual = contigmalloc(entries * sizeof(u_int32_t), M_AGP, 0, 18459747216SDoug Rabson 0, ~0, PAGE_SIZE, 0); 18559747216SDoug Rabson if (!gatt->ag_virtual) { 18659747216SDoug Rabson if (bootverbose) 18759747216SDoug Rabson device_printf(dev, "contiguous allocation failed\n"); 18859747216SDoug Rabson free(gatt, M_AGP); 18959747216SDoug Rabson return 0; 19059747216SDoug Rabson } 19159747216SDoug Rabson bzero(gatt->ag_virtual, entries * sizeof(u_int32_t)); 19259747216SDoug Rabson gatt->ag_physical = vtophys((vm_offset_t) gatt->ag_virtual); 19359747216SDoug Rabson agp_flush_cache(); 19459747216SDoug Rabson 19559747216SDoug Rabson return gatt; 19659747216SDoug Rabson } 19759747216SDoug Rabson 19859747216SDoug Rabson void 19959747216SDoug Rabson agp_free_gatt(struct agp_gatt *gatt) 20059747216SDoug Rabson { 20159747216SDoug Rabson contigfree(gatt->ag_virtual, 20259747216SDoug Rabson gatt->ag_entries * sizeof(u_int32_t), M_AGP); 20359747216SDoug Rabson free(gatt, M_AGP); 20459747216SDoug Rabson } 20559747216SDoug Rabson 20659747216SDoug Rabson static int agp_max[][2] = { 20759747216SDoug Rabson {0, 0}, 20859747216SDoug Rabson {32, 4}, 20959747216SDoug Rabson {64, 28}, 21059747216SDoug Rabson {128, 96}, 21159747216SDoug Rabson {256, 204}, 21259747216SDoug Rabson {512, 440}, 21359747216SDoug Rabson {1024, 942}, 21459747216SDoug Rabson {2048, 1920}, 21559747216SDoug Rabson {4096, 3932} 21659747216SDoug Rabson }; 21759747216SDoug Rabson #define agp_max_size (sizeof(agp_max) / sizeof(agp_max[0])) 21859747216SDoug Rabson 21959747216SDoug Rabson int 22059747216SDoug Rabson agp_generic_attach(device_t dev) 22159747216SDoug Rabson { 22259747216SDoug Rabson struct agp_softc *sc = device_get_softc(dev); 22359747216SDoug Rabson int rid, memsize, i; 22459747216SDoug Rabson 22559747216SDoug Rabson /* 22659747216SDoug Rabson * Find and map the aperture. 22759747216SDoug Rabson */ 22859747216SDoug Rabson rid = AGP_APBASE; 22959747216SDoug Rabson sc->as_aperture = bus_alloc_resource(dev, SYS_RES_MEMORY, &rid, 23059747216SDoug Rabson 0, ~0, 1, RF_ACTIVE); 23159747216SDoug Rabson if (!sc->as_aperture) 23259747216SDoug Rabson return ENOMEM; 23359747216SDoug Rabson 23459747216SDoug Rabson /* 23559747216SDoug Rabson * Work out an upper bound for agp memory allocation. This 23659747216SDoug Rabson * uses a heurisitc table from the Linux driver. 23759747216SDoug Rabson */ 23859747216SDoug Rabson memsize = ptoa(Maxmem) >> 20; 23959747216SDoug Rabson for (i = 0; i < agp_max_size; i++) { 24059747216SDoug Rabson if (memsize <= agp_max[i][0]) 24159747216SDoug Rabson break; 24259747216SDoug Rabson } 24359747216SDoug Rabson if (i == agp_max_size) i = agp_max_size - 1; 24459747216SDoug Rabson sc->as_maxmem = agp_max[i][1] << 20U; 24559747216SDoug Rabson 24659747216SDoug Rabson /* 24759747216SDoug Rabson * The lock is used to prevent re-entry to 24859747216SDoug Rabson * agp_generic_bind_memory() since that function can sleep. 24959747216SDoug Rabson */ 25059747216SDoug Rabson lockinit(&sc->as_lock, PZERO|PCATCH, "agplk", 0, 0); 25159747216SDoug Rabson 25259747216SDoug Rabson /* 25359747216SDoug Rabson * Initialise stuff for the userland device. 25459747216SDoug Rabson */ 25559747216SDoug Rabson agp_devclass = devclass_find("agp"); 25659747216SDoug Rabson TAILQ_INIT(&sc->as_memory); 25759747216SDoug Rabson sc->as_nextid = 1; 25859747216SDoug Rabson 25959747216SDoug Rabson sc->as_devnode = make_dev(&agp_cdevsw, 26059747216SDoug Rabson device_get_unit(dev), 26159747216SDoug Rabson UID_ROOT, 26259747216SDoug Rabson GID_WHEEL, 26359747216SDoug Rabson 0600, 26459747216SDoug Rabson "agpgart"); 26559747216SDoug Rabson 26659747216SDoug Rabson return 0; 26759747216SDoug Rabson } 26859747216SDoug Rabson 26959747216SDoug Rabson int 27059747216SDoug Rabson agp_generic_detach(device_t dev) 27159747216SDoug Rabson { 27259747216SDoug Rabson struct agp_softc *sc = device_get_softc(dev); 27359747216SDoug Rabson bus_release_resource(dev, SYS_RES_MEMORY, AGP_APBASE, sc->as_aperture); 274b40ce416SJulian Elischer lockmgr(&sc->as_lock, LK_DRAIN, 0, curthread); 275a18b1f1dSJason Evans lockdestroy(&sc->as_lock); 27659747216SDoug Rabson destroy_dev(sc->as_devnode); 27759747216SDoug Rabson agp_flush_cache(); 27859747216SDoug Rabson return 0; 27959747216SDoug Rabson } 28059747216SDoug Rabson 2819f9ccd20SJohn Baldwin /* 2829f9ccd20SJohn Baldwin * This does the enable logic for v3, with the same topology 2839f9ccd20SJohn Baldwin * restrictions as in place for v2 -- one bus, one device on the bus. 2849f9ccd20SJohn Baldwin */ 2859f9ccd20SJohn Baldwin static int 2869f9ccd20SJohn Baldwin agp_v3_enable(device_t dev, device_t mdev, u_int32_t mode) 28759747216SDoug Rabson { 28859747216SDoug Rabson u_int32_t tstatus, mstatus; 28959747216SDoug Rabson u_int32_t command; 2909f9ccd20SJohn Baldwin int rq, sba, fw, rate, arqsz, cal; 29159747216SDoug Rabson 2929f9ccd20SJohn Baldwin tstatus = pci_read_config(dev, agp_find_caps(dev) + AGP_STATUS, 4); 2939f9ccd20SJohn Baldwin mstatus = pci_read_config(mdev, agp_find_caps(mdev) + AGP_STATUS, 4); 2949f9ccd20SJohn Baldwin 2959f9ccd20SJohn Baldwin /* Set RQ to the min of mode, tstatus and mstatus */ 2969f9ccd20SJohn Baldwin rq = AGP_MODE_GET_RQ(mode); 2979f9ccd20SJohn Baldwin if (AGP_MODE_GET_RQ(tstatus) < rq) 2989f9ccd20SJohn Baldwin rq = AGP_MODE_GET_RQ(tstatus); 2999f9ccd20SJohn Baldwin if (AGP_MODE_GET_RQ(mstatus) < rq) 3009f9ccd20SJohn Baldwin rq = AGP_MODE_GET_RQ(mstatus); 3019f9ccd20SJohn Baldwin 3029f9ccd20SJohn Baldwin /* 3039f9ccd20SJohn Baldwin * ARQSZ - Set the value to the maximum one. 3049f9ccd20SJohn Baldwin * Don't allow the mode register to override values. 3059f9ccd20SJohn Baldwin */ 3069f9ccd20SJohn Baldwin arqsz = AGP_MODE_GET_ARQSZ(mode); 3079f9ccd20SJohn Baldwin if (AGP_MODE_GET_ARQSZ(tstatus) > rq) 3089f9ccd20SJohn Baldwin rq = AGP_MODE_GET_ARQSZ(tstatus); 3099f9ccd20SJohn Baldwin if (AGP_MODE_GET_ARQSZ(mstatus) > rq) 3109f9ccd20SJohn Baldwin rq = AGP_MODE_GET_ARQSZ(mstatus); 3119f9ccd20SJohn Baldwin 3129f9ccd20SJohn Baldwin /* Calibration cycle - don't allow override by mode register */ 3139f9ccd20SJohn Baldwin cal = AGP_MODE_GET_CAL(tstatus); 3149f9ccd20SJohn Baldwin if (AGP_MODE_GET_CAL(mstatus) < cal) 3159f9ccd20SJohn Baldwin cal = AGP_MODE_GET_CAL(mstatus); 3169f9ccd20SJohn Baldwin 3179f9ccd20SJohn Baldwin /* SBA must be supported for AGP v3. */ 3189f9ccd20SJohn Baldwin sba = 1; 3199f9ccd20SJohn Baldwin 3209f9ccd20SJohn Baldwin /* Set FW if all three support it. */ 3219f9ccd20SJohn Baldwin fw = (AGP_MODE_GET_FW(tstatus) 3229f9ccd20SJohn Baldwin & AGP_MODE_GET_FW(mstatus) 3239f9ccd20SJohn Baldwin & AGP_MODE_GET_FW(mode)); 3249f9ccd20SJohn Baldwin 3259f9ccd20SJohn Baldwin /* Figure out the max rate */ 3269f9ccd20SJohn Baldwin rate = (AGP_MODE_GET_RATE(tstatus) 3279f9ccd20SJohn Baldwin & AGP_MODE_GET_RATE(mstatus) 3289f9ccd20SJohn Baldwin & AGP_MODE_GET_RATE(mode)); 3299f9ccd20SJohn Baldwin if (rate & AGP_MODE_V3_RATE_8x) 3309f9ccd20SJohn Baldwin rate = AGP_MODE_V3_RATE_8x; 3319f9ccd20SJohn Baldwin else 3329f9ccd20SJohn Baldwin rate = AGP_MODE_V3_RATE_4x; 3339f9ccd20SJohn Baldwin if (bootverbose) 3349f9ccd20SJohn Baldwin device_printf(dev, "Setting AGP v3 mode %d\n", rate * 4); 3359f9ccd20SJohn Baldwin 3369f9ccd20SJohn Baldwin pci_write_config(dev, agp_find_caps(dev) + AGP_COMMAND, 0, 4); 3379f9ccd20SJohn Baldwin 3389f9ccd20SJohn Baldwin /* Construct the new mode word and tell the hardware */ 3399f9ccd20SJohn Baldwin command = AGP_MODE_SET_RQ(0, rq); 3409f9ccd20SJohn Baldwin command = AGP_MODE_SET_ARQSZ(command, arqsz); 3419f9ccd20SJohn Baldwin command = AGP_MODE_SET_CAL(command, cal); 3429f9ccd20SJohn Baldwin command = AGP_MODE_SET_SBA(command, sba); 3439f9ccd20SJohn Baldwin command = AGP_MODE_SET_FW(command, fw); 3449f9ccd20SJohn Baldwin command = AGP_MODE_SET_RATE(command, rate); 3459f9ccd20SJohn Baldwin command = AGP_MODE_SET_AGP(command, 1); 3469f9ccd20SJohn Baldwin pci_write_config(dev, agp_find_caps(dev) + AGP_COMMAND, command, 4); 3479f9ccd20SJohn Baldwin pci_write_config(mdev, agp_find_caps(mdev) + AGP_COMMAND, command, 4); 3489f9ccd20SJohn Baldwin 3499f9ccd20SJohn Baldwin return 0; 35059747216SDoug Rabson } 35159747216SDoug Rabson 3529f9ccd20SJohn Baldwin static int 3539f9ccd20SJohn Baldwin agp_v2_enable(device_t dev, device_t mdev, u_int32_t mode) 3549f9ccd20SJohn Baldwin { 3559f9ccd20SJohn Baldwin u_int32_t tstatus, mstatus; 3569f9ccd20SJohn Baldwin u_int32_t command; 3579f9ccd20SJohn Baldwin int rq, sba, fw, rate; 3589f9ccd20SJohn Baldwin 35959747216SDoug Rabson tstatus = pci_read_config(dev, agp_find_caps(dev) + AGP_STATUS, 4); 36059747216SDoug Rabson mstatus = pci_read_config(mdev, agp_find_caps(mdev) + AGP_STATUS, 4); 36159747216SDoug Rabson 36259747216SDoug Rabson /* Set RQ to the min of mode, tstatus and mstatus */ 36359747216SDoug Rabson rq = AGP_MODE_GET_RQ(mode); 36459747216SDoug Rabson if (AGP_MODE_GET_RQ(tstatus) < rq) 36559747216SDoug Rabson rq = AGP_MODE_GET_RQ(tstatus); 36659747216SDoug Rabson if (AGP_MODE_GET_RQ(mstatus) < rq) 36759747216SDoug Rabson rq = AGP_MODE_GET_RQ(mstatus); 36859747216SDoug Rabson 36959747216SDoug Rabson /* Set SBA if all three can deal with SBA */ 37059747216SDoug Rabson sba = (AGP_MODE_GET_SBA(tstatus) 37159747216SDoug Rabson & AGP_MODE_GET_SBA(mstatus) 37259747216SDoug Rabson & AGP_MODE_GET_SBA(mode)); 37359747216SDoug Rabson 37459747216SDoug Rabson /* Similar for FW */ 37559747216SDoug Rabson fw = (AGP_MODE_GET_FW(tstatus) 37659747216SDoug Rabson & AGP_MODE_GET_FW(mstatus) 37759747216SDoug Rabson & AGP_MODE_GET_FW(mode)); 37859747216SDoug Rabson 37959747216SDoug Rabson /* Figure out the max rate */ 38059747216SDoug Rabson rate = (AGP_MODE_GET_RATE(tstatus) 38159747216SDoug Rabson & AGP_MODE_GET_RATE(mstatus) 38259747216SDoug Rabson & AGP_MODE_GET_RATE(mode)); 3839f9ccd20SJohn Baldwin if (rate & AGP_MODE_V2_RATE_4x) 3849f9ccd20SJohn Baldwin rate = AGP_MODE_V2_RATE_4x; 3859f9ccd20SJohn Baldwin else if (rate & AGP_MODE_V2_RATE_2x) 3869f9ccd20SJohn Baldwin rate = AGP_MODE_V2_RATE_2x; 38759747216SDoug Rabson else 3889f9ccd20SJohn Baldwin rate = AGP_MODE_V2_RATE_1x; 3899f9ccd20SJohn Baldwin if (bootverbose) 3909f9ccd20SJohn Baldwin device_printf(dev, "Setting AGP v2 mode %d\n", rate); 39159747216SDoug Rabson 39259747216SDoug Rabson /* Construct the new mode word and tell the hardware */ 39359747216SDoug Rabson command = AGP_MODE_SET_RQ(0, rq); 39459747216SDoug Rabson command = AGP_MODE_SET_SBA(command, sba); 39559747216SDoug Rabson command = AGP_MODE_SET_FW(command, fw); 39659747216SDoug Rabson command = AGP_MODE_SET_RATE(command, rate); 39759747216SDoug Rabson command = AGP_MODE_SET_AGP(command, 1); 39859747216SDoug Rabson pci_write_config(dev, agp_find_caps(dev) + AGP_COMMAND, command, 4); 39959747216SDoug Rabson pci_write_config(mdev, agp_find_caps(mdev) + AGP_COMMAND, command, 4); 40059747216SDoug Rabson 40159747216SDoug Rabson return 0; 40259747216SDoug Rabson } 40359747216SDoug Rabson 4049f9ccd20SJohn Baldwin int 4059f9ccd20SJohn Baldwin agp_generic_enable(device_t dev, u_int32_t mode) 4069f9ccd20SJohn Baldwin { 4079f9ccd20SJohn Baldwin device_t mdev = agp_find_display(); 4089f9ccd20SJohn Baldwin u_int32_t tstatus, mstatus; 4099f9ccd20SJohn Baldwin 4109f9ccd20SJohn Baldwin if (!mdev) { 4119f9ccd20SJohn Baldwin AGP_DPF("can't find display\n"); 4129f9ccd20SJohn Baldwin return ENXIO; 4139f9ccd20SJohn Baldwin } 4149f9ccd20SJohn Baldwin 4159f9ccd20SJohn Baldwin tstatus = pci_read_config(dev, agp_find_caps(dev) + AGP_STATUS, 4); 4169f9ccd20SJohn Baldwin mstatus = pci_read_config(mdev, agp_find_caps(mdev) + AGP_STATUS, 4); 4179f9ccd20SJohn Baldwin 4189f9ccd20SJohn Baldwin /* 4199f9ccd20SJohn Baldwin * Check display and bridge for AGP v3 support. AGP v3 allows 4209f9ccd20SJohn Baldwin * more variety in topology than v2, e.g. multiple AGP devices 4219f9ccd20SJohn Baldwin * attached to one bridge, or multiple AGP bridges in one 4229f9ccd20SJohn Baldwin * system. This doesn't attempt to address those situations, 4239f9ccd20SJohn Baldwin * but should work fine for a classic single AGP slot system 4249f9ccd20SJohn Baldwin * with AGP v3. 4259f9ccd20SJohn Baldwin */ 4269f9ccd20SJohn Baldwin if (AGP_MODE_GET_MODE_3(tstatus) && AGP_MODE_GET_MODE_3(mstatus)) 4279f9ccd20SJohn Baldwin return (agp_v3_enable(dev, mdev, mode)); 4289f9ccd20SJohn Baldwin else 4299f9ccd20SJohn Baldwin return (agp_v2_enable(dev, mdev, mode)); 4309f9ccd20SJohn Baldwin } 4319f9ccd20SJohn Baldwin 43259747216SDoug Rabson struct agp_memory * 43359747216SDoug Rabson agp_generic_alloc_memory(device_t dev, int type, vm_size_t size) 43459747216SDoug Rabson { 43559747216SDoug Rabson struct agp_softc *sc = device_get_softc(dev); 43659747216SDoug Rabson struct agp_memory *mem; 43759747216SDoug Rabson 43859747216SDoug Rabson if ((size & (AGP_PAGE_SIZE - 1)) != 0) 43959747216SDoug Rabson return 0; 44059747216SDoug Rabson 44159747216SDoug Rabson if (sc->as_allocated + size > sc->as_maxmem) 44259747216SDoug Rabson return 0; 44359747216SDoug Rabson 444e547d6fdSDoug Rabson if (type != 0) { 445e547d6fdSDoug Rabson printf("agp_generic_alloc_memory: unsupported type %d\n", 446e547d6fdSDoug Rabson type); 447e547d6fdSDoug Rabson return 0; 448e547d6fdSDoug Rabson } 449e547d6fdSDoug Rabson 450a163d034SWarner Losh mem = malloc(sizeof *mem, M_AGP, M_WAITOK); 45159747216SDoug Rabson mem->am_id = sc->as_nextid++; 45259747216SDoug Rabson mem->am_size = size; 453e547d6fdSDoug Rabson mem->am_type = 0; 45459747216SDoug Rabson mem->am_obj = vm_object_allocate(OBJT_DEFAULT, atop(round_page(size))); 45559747216SDoug Rabson mem->am_physical = 0; 45659747216SDoug Rabson mem->am_offset = 0; 45759747216SDoug Rabson mem->am_is_bound = 0; 45859747216SDoug Rabson TAILQ_INSERT_TAIL(&sc->as_memory, mem, am_link); 45959747216SDoug Rabson sc->as_allocated += size; 46059747216SDoug Rabson 46159747216SDoug Rabson return mem; 46259747216SDoug Rabson } 46359747216SDoug Rabson 46459747216SDoug Rabson int 46559747216SDoug Rabson agp_generic_free_memory(device_t dev, struct agp_memory *mem) 46659747216SDoug Rabson { 46759747216SDoug Rabson struct agp_softc *sc = device_get_softc(dev); 46859747216SDoug Rabson 46959747216SDoug Rabson if (mem->am_is_bound) 47059747216SDoug Rabson return EBUSY; 47159747216SDoug Rabson 47259747216SDoug Rabson sc->as_allocated -= mem->am_size; 47359747216SDoug Rabson TAILQ_REMOVE(&sc->as_memory, mem, am_link); 47459747216SDoug Rabson vm_object_deallocate(mem->am_obj); 47559747216SDoug Rabson free(mem, M_AGP); 47659747216SDoug Rabson return 0; 47759747216SDoug Rabson } 47859747216SDoug Rabson 47959747216SDoug Rabson int 48059747216SDoug Rabson agp_generic_bind_memory(device_t dev, struct agp_memory *mem, 48159747216SDoug Rabson vm_offset_t offset) 48259747216SDoug Rabson { 48359747216SDoug Rabson struct agp_softc *sc = device_get_softc(dev); 48459747216SDoug Rabson vm_offset_t i, j, k; 48559747216SDoug Rabson vm_page_t m; 48659747216SDoug Rabson int error; 48759747216SDoug Rabson 488b40ce416SJulian Elischer lockmgr(&sc->as_lock, LK_EXCLUSIVE, 0, curthread); 48959747216SDoug Rabson 49059747216SDoug Rabson if (mem->am_is_bound) { 49159747216SDoug Rabson device_printf(dev, "memory already bound\n"); 49259747216SDoug Rabson return EINVAL; 49359747216SDoug Rabson } 49459747216SDoug Rabson 49559747216SDoug Rabson if (offset < 0 49659747216SDoug Rabson || (offset & (AGP_PAGE_SIZE - 1)) != 0 49759747216SDoug Rabson || offset + mem->am_size > AGP_GET_APERTURE(dev)) { 49859747216SDoug Rabson device_printf(dev, "binding memory at bad offset %#x\n", 49959747216SDoug Rabson (int) offset); 50059747216SDoug Rabson return EINVAL; 50159747216SDoug Rabson } 50259747216SDoug Rabson 50359747216SDoug Rabson /* 50459747216SDoug Rabson * Bind the individual pages and flush the chipset's 50559747216SDoug Rabson * TLB. 50659747216SDoug Rabson * 50759747216SDoug Rabson * XXX Presumably, this needs to be the pci address on alpha 50859747216SDoug Rabson * (i.e. use alpha_XXX_dmamap()). I don't have access to any 50959747216SDoug Rabson * alpha AGP hardware to check. 51059747216SDoug Rabson */ 51159747216SDoug Rabson for (i = 0; i < mem->am_size; i += PAGE_SIZE) { 51259747216SDoug Rabson /* 51359747216SDoug Rabson * Find a page from the object and wire it 51459747216SDoug Rabson * down. This page will be mapped using one or more 51559747216SDoug Rabson * entries in the GATT (assuming that PAGE_SIZE >= 51659747216SDoug Rabson * AGP_PAGE_SIZE. If this is the first call to bind, 51759747216SDoug Rabson * the pages will be allocated and zeroed. 51859747216SDoug Rabson */ 519f873ed03SAlan Cox VM_OBJECT_LOCK(mem->am_obj); 52059747216SDoug Rabson m = vm_page_grab(mem->am_obj, OFF_TO_IDX(i), 521fab965bfSAlan Cox VM_ALLOC_WIRED | VM_ALLOC_ZERO | VM_ALLOC_RETRY); 522f873ed03SAlan Cox VM_OBJECT_UNLOCK(mem->am_obj); 5235ec699cdSAlan Cox if ((m->flags & PG_ZERO) == 0) 524fff6062aSAlan Cox pmap_zero_page(m); 52559747216SDoug Rabson AGP_DPF("found page pa=%#x\n", VM_PAGE_TO_PHYS(m)); 52659747216SDoug Rabson 52759747216SDoug Rabson /* 52859747216SDoug Rabson * Install entries in the GATT, making sure that if 52959747216SDoug Rabson * AGP_PAGE_SIZE < PAGE_SIZE and mem->am_size is not 53059747216SDoug Rabson * aligned to PAGE_SIZE, we don't modify too many GATT 53159747216SDoug Rabson * entries. 53259747216SDoug Rabson */ 53359747216SDoug Rabson for (j = 0; j < PAGE_SIZE && i + j < mem->am_size; 53459747216SDoug Rabson j += AGP_PAGE_SIZE) { 53559747216SDoug Rabson vm_offset_t pa = VM_PAGE_TO_PHYS(m) + j; 53659747216SDoug Rabson AGP_DPF("binding offset %#x to pa %#x\n", 53759747216SDoug Rabson offset + i + j, pa); 53859747216SDoug Rabson error = AGP_BIND_PAGE(dev, offset + i + j, pa); 53959747216SDoug Rabson if (error) { 54059747216SDoug Rabson /* 54159747216SDoug Rabson * Bail out. Reverse all the mappings 54259747216SDoug Rabson * and unwire the pages. 54359747216SDoug Rabson */ 544e7863f18SAlan Cox vm_page_lock_queues(); 54559747216SDoug Rabson vm_page_wakeup(m); 546e7863f18SAlan Cox vm_page_unlock_queues(); 54759747216SDoug Rabson for (k = 0; k < i + j; k += AGP_PAGE_SIZE) 54859747216SDoug Rabson AGP_UNBIND_PAGE(dev, offset + k); 549f873ed03SAlan Cox VM_OBJECT_LOCK(mem->am_obj); 55059747216SDoug Rabson for (k = 0; k <= i; k += PAGE_SIZE) { 55159747216SDoug Rabson m = vm_page_lookup(mem->am_obj, 55259747216SDoug Rabson OFF_TO_IDX(k)); 5531f545269SAlan Cox vm_page_lock_queues(); 55459747216SDoug Rabson vm_page_unwire(m, 0); 5551f545269SAlan Cox vm_page_unlock_queues(); 55659747216SDoug Rabson } 557f873ed03SAlan Cox VM_OBJECT_UNLOCK(mem->am_obj); 558b40ce416SJulian Elischer lockmgr(&sc->as_lock, LK_RELEASE, 0, curthread); 55959747216SDoug Rabson return error; 56059747216SDoug Rabson } 56159747216SDoug Rabson } 562e7863f18SAlan Cox vm_page_lock_queues(); 56359747216SDoug Rabson vm_page_wakeup(m); 564e7863f18SAlan Cox vm_page_unlock_queues(); 56559747216SDoug Rabson } 56659747216SDoug Rabson 56759747216SDoug Rabson /* 56859747216SDoug Rabson * Flush the cpu cache since we are providing a new mapping 56959747216SDoug Rabson * for these pages. 57059747216SDoug Rabson */ 57159747216SDoug Rabson agp_flush_cache(); 57259747216SDoug Rabson 57359747216SDoug Rabson /* 57459747216SDoug Rabson * Make sure the chipset gets the new mappings. 57559747216SDoug Rabson */ 57659747216SDoug Rabson AGP_FLUSH_TLB(dev); 57759747216SDoug Rabson 57859747216SDoug Rabson mem->am_offset = offset; 57959747216SDoug Rabson mem->am_is_bound = 1; 58059747216SDoug Rabson 581b40ce416SJulian Elischer lockmgr(&sc->as_lock, LK_RELEASE, 0, curthread); 58259747216SDoug Rabson 58359747216SDoug Rabson return 0; 58459747216SDoug Rabson } 58559747216SDoug Rabson 58659747216SDoug Rabson int 58759747216SDoug Rabson agp_generic_unbind_memory(device_t dev, struct agp_memory *mem) 58859747216SDoug Rabson { 58959747216SDoug Rabson struct agp_softc *sc = device_get_softc(dev); 59059747216SDoug Rabson vm_page_t m; 59159747216SDoug Rabson int i; 59259747216SDoug Rabson 593b40ce416SJulian Elischer lockmgr(&sc->as_lock, LK_EXCLUSIVE, 0, curthread); 59459747216SDoug Rabson 59559747216SDoug Rabson if (!mem->am_is_bound) { 59659747216SDoug Rabson device_printf(dev, "memory is not bound\n"); 59759747216SDoug Rabson return EINVAL; 59859747216SDoug Rabson } 59959747216SDoug Rabson 60059747216SDoug Rabson 60159747216SDoug Rabson /* 60259747216SDoug Rabson * Unbind the individual pages and flush the chipset's 60359747216SDoug Rabson * TLB. Unwire the pages so they can be swapped. 60459747216SDoug Rabson */ 60559747216SDoug Rabson for (i = 0; i < mem->am_size; i += AGP_PAGE_SIZE) 60659747216SDoug Rabson AGP_UNBIND_PAGE(dev, mem->am_offset + i); 607f873ed03SAlan Cox VM_OBJECT_LOCK(mem->am_obj); 60859747216SDoug Rabson for (i = 0; i < mem->am_size; i += PAGE_SIZE) { 60959747216SDoug Rabson m = vm_page_lookup(mem->am_obj, atop(i)); 6101f545269SAlan Cox vm_page_lock_queues(); 61159747216SDoug Rabson vm_page_unwire(m, 0); 6121f545269SAlan Cox vm_page_unlock_queues(); 61359747216SDoug Rabson } 614f873ed03SAlan Cox VM_OBJECT_UNLOCK(mem->am_obj); 61559747216SDoug Rabson 61659747216SDoug Rabson agp_flush_cache(); 61759747216SDoug Rabson AGP_FLUSH_TLB(dev); 61859747216SDoug Rabson 61959747216SDoug Rabson mem->am_offset = 0; 62059747216SDoug Rabson mem->am_is_bound = 0; 62159747216SDoug Rabson 622b40ce416SJulian Elischer lockmgr(&sc->as_lock, LK_RELEASE, 0, curthread); 62359747216SDoug Rabson 62459747216SDoug Rabson return 0; 62559747216SDoug Rabson } 62659747216SDoug Rabson 62759747216SDoug Rabson /* Helper functions for implementing user/kernel api */ 62859747216SDoug Rabson 62959747216SDoug Rabson static int 63059747216SDoug Rabson agp_acquire_helper(device_t dev, enum agp_acquire_state state) 63159747216SDoug Rabson { 63259747216SDoug Rabson struct agp_softc *sc = device_get_softc(dev); 63359747216SDoug Rabson 63459747216SDoug Rabson if (sc->as_state != AGP_ACQUIRE_FREE) 63559747216SDoug Rabson return EBUSY; 63659747216SDoug Rabson sc->as_state = state; 63759747216SDoug Rabson 63859747216SDoug Rabson return 0; 63959747216SDoug Rabson } 64059747216SDoug Rabson 64159747216SDoug Rabson static int 64259747216SDoug Rabson agp_release_helper(device_t dev, enum agp_acquire_state state) 64359747216SDoug Rabson { 64459747216SDoug Rabson struct agp_softc *sc = device_get_softc(dev); 64559747216SDoug Rabson 64659747216SDoug Rabson if (sc->as_state == AGP_ACQUIRE_FREE) 64759747216SDoug Rabson return 0; 64859747216SDoug Rabson 64959747216SDoug Rabson if (sc->as_state != state) 65059747216SDoug Rabson return EBUSY; 65159747216SDoug Rabson 65259747216SDoug Rabson sc->as_state = AGP_ACQUIRE_FREE; 65359747216SDoug Rabson return 0; 65459747216SDoug Rabson } 65559747216SDoug Rabson 65659747216SDoug Rabson static struct agp_memory * 65759747216SDoug Rabson agp_find_memory(device_t dev, int id) 65859747216SDoug Rabson { 65959747216SDoug Rabson struct agp_softc *sc = device_get_softc(dev); 66059747216SDoug Rabson struct agp_memory *mem; 66159747216SDoug Rabson 66259747216SDoug Rabson AGP_DPF("searching for memory block %d\n", id); 66359747216SDoug Rabson TAILQ_FOREACH(mem, &sc->as_memory, am_link) { 66459747216SDoug Rabson AGP_DPF("considering memory block %d\n", mem->am_id); 66559747216SDoug Rabson if (mem->am_id == id) 66659747216SDoug Rabson return mem; 66759747216SDoug Rabson } 66859747216SDoug Rabson return 0; 66959747216SDoug Rabson } 67059747216SDoug Rabson 67159747216SDoug Rabson /* Implementation of the userland ioctl api */ 67259747216SDoug Rabson 67359747216SDoug Rabson static int 67459747216SDoug Rabson agp_info_user(device_t dev, agp_info *info) 67559747216SDoug Rabson { 67659747216SDoug Rabson struct agp_softc *sc = device_get_softc(dev); 67759747216SDoug Rabson 67859747216SDoug Rabson bzero(info, sizeof *info); 67959747216SDoug Rabson info->bridge_id = pci_get_devid(dev); 68059747216SDoug Rabson info->agp_mode = 68159747216SDoug Rabson pci_read_config(dev, agp_find_caps(dev) + AGP_STATUS, 4); 68259747216SDoug Rabson info->aper_base = rman_get_start(sc->as_aperture); 68359747216SDoug Rabson info->aper_size = AGP_GET_APERTURE(dev) >> 20; 68459747216SDoug Rabson info->pg_total = info->pg_system = sc->as_maxmem >> AGP_PAGE_SHIFT; 68559747216SDoug Rabson info->pg_used = sc->as_allocated >> AGP_PAGE_SHIFT; 68659747216SDoug Rabson 68759747216SDoug Rabson return 0; 68859747216SDoug Rabson } 68959747216SDoug Rabson 69059747216SDoug Rabson static int 69159747216SDoug Rabson agp_setup_user(device_t dev, agp_setup *setup) 69259747216SDoug Rabson { 69359747216SDoug Rabson return AGP_ENABLE(dev, setup->agp_mode); 69459747216SDoug Rabson } 69559747216SDoug Rabson 69659747216SDoug Rabson static int 69759747216SDoug Rabson agp_allocate_user(device_t dev, agp_allocate *alloc) 69859747216SDoug Rabson { 69959747216SDoug Rabson struct agp_memory *mem; 70059747216SDoug Rabson 70159747216SDoug Rabson mem = AGP_ALLOC_MEMORY(dev, 70259747216SDoug Rabson alloc->type, 70359747216SDoug Rabson alloc->pg_count << AGP_PAGE_SHIFT); 704e547d6fdSDoug Rabson if (mem) { 70559747216SDoug Rabson alloc->key = mem->am_id; 70659747216SDoug Rabson alloc->physical = mem->am_physical; 70759747216SDoug Rabson return 0; 708e547d6fdSDoug Rabson } else { 709e547d6fdSDoug Rabson return ENOMEM; 710e547d6fdSDoug Rabson } 71159747216SDoug Rabson } 71259747216SDoug Rabson 71359747216SDoug Rabson static int 71459747216SDoug Rabson agp_deallocate_user(device_t dev, int id) 71559747216SDoug Rabson { 71659747216SDoug Rabson struct agp_memory *mem = agp_find_memory(dev, id);; 71759747216SDoug Rabson 71859747216SDoug Rabson if (mem) { 71959747216SDoug Rabson AGP_FREE_MEMORY(dev, mem); 72059747216SDoug Rabson return 0; 72159747216SDoug Rabson } else { 72259747216SDoug Rabson return ENOENT; 72359747216SDoug Rabson } 72459747216SDoug Rabson } 72559747216SDoug Rabson 72659747216SDoug Rabson static int 72759747216SDoug Rabson agp_bind_user(device_t dev, agp_bind *bind) 72859747216SDoug Rabson { 72959747216SDoug Rabson struct agp_memory *mem = agp_find_memory(dev, bind->key); 73059747216SDoug Rabson 73159747216SDoug Rabson if (!mem) 73259747216SDoug Rabson return ENOENT; 73359747216SDoug Rabson 73459747216SDoug Rabson return AGP_BIND_MEMORY(dev, mem, bind->pg_start << AGP_PAGE_SHIFT); 73559747216SDoug Rabson } 73659747216SDoug Rabson 73759747216SDoug Rabson static int 73859747216SDoug Rabson agp_unbind_user(device_t dev, agp_unbind *unbind) 73959747216SDoug Rabson { 74059747216SDoug Rabson struct agp_memory *mem = agp_find_memory(dev, unbind->key); 74159747216SDoug Rabson 74259747216SDoug Rabson if (!mem) 74359747216SDoug Rabson return ENOENT; 74459747216SDoug Rabson 74559747216SDoug Rabson return AGP_UNBIND_MEMORY(dev, mem); 74659747216SDoug Rabson } 74759747216SDoug Rabson 74859747216SDoug Rabson static int 749b40ce416SJulian Elischer agp_open(dev_t kdev, int oflags, int devtype, struct thread *td) 75059747216SDoug Rabson { 75159747216SDoug Rabson device_t dev = KDEV2DEV(kdev); 75259747216SDoug Rabson struct agp_softc *sc = device_get_softc(dev); 75359747216SDoug Rabson 75459747216SDoug Rabson if (!sc->as_isopen) { 75559747216SDoug Rabson sc->as_isopen = 1; 75659747216SDoug Rabson device_busy(dev); 75759747216SDoug Rabson } 75859747216SDoug Rabson 75959747216SDoug Rabson return 0; 76059747216SDoug Rabson } 76159747216SDoug Rabson 76259747216SDoug Rabson static int 763b40ce416SJulian Elischer agp_close(dev_t kdev, int fflag, int devtype, struct thread *td) 76459747216SDoug Rabson { 76559747216SDoug Rabson device_t dev = KDEV2DEV(kdev); 76659747216SDoug Rabson struct agp_softc *sc = device_get_softc(dev); 7673e0cee70SRuslan Ermilov struct agp_memory *mem; 76859747216SDoug Rabson 76959747216SDoug Rabson /* 77059747216SDoug Rabson * Clear the GATT and force release on last close 77159747216SDoug Rabson */ 7723e0cee70SRuslan Ermilov while ((mem = TAILQ_FIRST(&sc->as_memory)) != 0) { 7733e0cee70SRuslan Ermilov if (mem->am_is_bound) 7743e0cee70SRuslan Ermilov AGP_UNBIND_MEMORY(dev, mem); 7753e0cee70SRuslan Ermilov AGP_FREE_MEMORY(dev, mem); 7763e0cee70SRuslan Ermilov } 77759747216SDoug Rabson if (sc->as_state == AGP_ACQUIRE_USER) 77859747216SDoug Rabson agp_release_helper(dev, AGP_ACQUIRE_USER); 77959747216SDoug Rabson sc->as_isopen = 0; 78059747216SDoug Rabson device_unbusy(dev); 78159747216SDoug Rabson 78259747216SDoug Rabson return 0; 78359747216SDoug Rabson } 78459747216SDoug Rabson 78559747216SDoug Rabson static int 786b40ce416SJulian Elischer agp_ioctl(dev_t kdev, u_long cmd, caddr_t data, int fflag, struct thread *td) 78759747216SDoug Rabson { 78859747216SDoug Rabson device_t dev = KDEV2DEV(kdev); 78959747216SDoug Rabson 79059747216SDoug Rabson switch (cmd) { 79159747216SDoug Rabson case AGPIOC_INFO: 79259747216SDoug Rabson return agp_info_user(dev, (agp_info *) data); 79359747216SDoug Rabson 79459747216SDoug Rabson case AGPIOC_ACQUIRE: 79559747216SDoug Rabson return agp_acquire_helper(dev, AGP_ACQUIRE_USER); 79659747216SDoug Rabson 79759747216SDoug Rabson case AGPIOC_RELEASE: 79859747216SDoug Rabson return agp_release_helper(dev, AGP_ACQUIRE_USER); 79959747216SDoug Rabson 80059747216SDoug Rabson case AGPIOC_SETUP: 80159747216SDoug Rabson return agp_setup_user(dev, (agp_setup *)data); 80259747216SDoug Rabson 80359747216SDoug Rabson case AGPIOC_ALLOCATE: 80459747216SDoug Rabson return agp_allocate_user(dev, (agp_allocate *)data); 80559747216SDoug Rabson 80659747216SDoug Rabson case AGPIOC_DEALLOCATE: 80759747216SDoug Rabson return agp_deallocate_user(dev, *(int *) data); 80859747216SDoug Rabson 80959747216SDoug Rabson case AGPIOC_BIND: 81059747216SDoug Rabson return agp_bind_user(dev, (agp_bind *)data); 81159747216SDoug Rabson 81259747216SDoug Rabson case AGPIOC_UNBIND: 81359747216SDoug Rabson return agp_unbind_user(dev, (agp_unbind *)data); 81459747216SDoug Rabson 81559747216SDoug Rabson } 81659747216SDoug Rabson 81759747216SDoug Rabson return EINVAL; 81859747216SDoug Rabson } 81959747216SDoug Rabson 82059747216SDoug Rabson static int 821227f9a1cSJake Burkholder agp_mmap(dev_t kdev, vm_offset_t offset, vm_paddr_t *paddr, int prot) 82259747216SDoug Rabson { 82359747216SDoug Rabson device_t dev = KDEV2DEV(kdev); 82459747216SDoug Rabson struct agp_softc *sc = device_get_softc(dev); 82559747216SDoug Rabson 82659747216SDoug Rabson if (offset > AGP_GET_APERTURE(dev)) 82759747216SDoug Rabson return -1; 82807159f9cSMaxime Henrion *paddr = rman_get_start(sc->as_aperture) + offset; 82907159f9cSMaxime Henrion return 0; 83059747216SDoug Rabson } 83159747216SDoug Rabson 83259747216SDoug Rabson /* Implementation of the kernel api */ 83359747216SDoug Rabson 83459747216SDoug Rabson device_t 83559747216SDoug Rabson agp_find_device() 83659747216SDoug Rabson { 83759747216SDoug Rabson if (!agp_devclass) 83859747216SDoug Rabson return 0; 83959747216SDoug Rabson return devclass_get_device(agp_devclass, 0); 84059747216SDoug Rabson } 84159747216SDoug Rabson 84259747216SDoug Rabson enum agp_acquire_state 84359747216SDoug Rabson agp_state(device_t dev) 84459747216SDoug Rabson { 84559747216SDoug Rabson struct agp_softc *sc = device_get_softc(dev); 84659747216SDoug Rabson return sc->as_state; 84759747216SDoug Rabson } 84859747216SDoug Rabson 84959747216SDoug Rabson void 85059747216SDoug Rabson agp_get_info(device_t dev, struct agp_info *info) 85159747216SDoug Rabson { 85259747216SDoug Rabson struct agp_softc *sc = device_get_softc(dev); 85359747216SDoug Rabson 85459747216SDoug Rabson info->ai_mode = 85559747216SDoug Rabson pci_read_config(dev, agp_find_caps(dev) + AGP_STATUS, 4); 85659747216SDoug Rabson info->ai_aperture_base = rman_get_start(sc->as_aperture); 857df585170SPeter Wemm info->ai_aperture_size = rman_get_size(sc->as_aperture); 858fe707548SMatthew N. Dodd info->ai_aperture_va = (vm_offset_t) rman_get_virtual(sc->as_aperture); 85959747216SDoug Rabson info->ai_memory_allowed = sc->as_maxmem; 86059747216SDoug Rabson info->ai_memory_used = sc->as_allocated; 86159747216SDoug Rabson } 86259747216SDoug Rabson 86359747216SDoug Rabson int 86459747216SDoug Rabson agp_acquire(device_t dev) 86559747216SDoug Rabson { 86659747216SDoug Rabson return agp_acquire_helper(dev, AGP_ACQUIRE_KERNEL); 86759747216SDoug Rabson } 86859747216SDoug Rabson 86959747216SDoug Rabson int 87059747216SDoug Rabson agp_release(device_t dev) 87159747216SDoug Rabson { 87259747216SDoug Rabson return agp_release_helper(dev, AGP_ACQUIRE_KERNEL); 87359747216SDoug Rabson } 87459747216SDoug Rabson 87559747216SDoug Rabson int 87659747216SDoug Rabson agp_enable(device_t dev, u_int32_t mode) 87759747216SDoug Rabson { 87859747216SDoug Rabson return AGP_ENABLE(dev, mode); 87959747216SDoug Rabson } 88059747216SDoug Rabson 88159747216SDoug Rabson void *agp_alloc_memory(device_t dev, int type, vm_size_t bytes) 88259747216SDoug Rabson { 88359747216SDoug Rabson return (void *) AGP_ALLOC_MEMORY(dev, type, bytes); 88459747216SDoug Rabson } 88559747216SDoug Rabson 88659747216SDoug Rabson void agp_free_memory(device_t dev, void *handle) 88759747216SDoug Rabson { 88859747216SDoug Rabson struct agp_memory *mem = (struct agp_memory *) handle; 88959747216SDoug Rabson AGP_FREE_MEMORY(dev, mem); 89059747216SDoug Rabson } 89159747216SDoug Rabson 89259747216SDoug Rabson int agp_bind_memory(device_t dev, void *handle, vm_offset_t offset) 89359747216SDoug Rabson { 89459747216SDoug Rabson struct agp_memory *mem = (struct agp_memory *) handle; 89559747216SDoug Rabson return AGP_BIND_MEMORY(dev, mem, offset); 89659747216SDoug Rabson } 89759747216SDoug Rabson 89859747216SDoug Rabson int agp_unbind_memory(device_t dev, void *handle) 89959747216SDoug Rabson { 90059747216SDoug Rabson struct agp_memory *mem = (struct agp_memory *) handle; 90159747216SDoug Rabson return AGP_UNBIND_MEMORY(dev, mem); 90259747216SDoug Rabson } 90359747216SDoug Rabson 90459747216SDoug Rabson void agp_memory_info(device_t dev, void *handle, struct 90559747216SDoug Rabson agp_memory_info *mi) 90659747216SDoug Rabson { 90759747216SDoug Rabson struct agp_memory *mem = (struct agp_memory *) handle; 90859747216SDoug Rabson 90959747216SDoug Rabson mi->ami_size = mem->am_size; 91059747216SDoug Rabson mi->ami_physical = mem->am_physical; 91159747216SDoug Rabson mi->ami_offset = mem->am_offset; 91259747216SDoug Rabson mi->ami_is_bound = mem->am_is_bound; 91359747216SDoug Rabson } 914