265 lines
8.6 KiB
C
265 lines
8.6 KiB
C
/* $NetBSD: agpvar.h,v 1.4 2001/10/01 21:54:48 fvdl Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 2000 Doug Rabson
|
|
* 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.
|
|
*
|
|
* $FreeBSD: src/sys/pci/agppriv.h,v 1.3 2000/07/12 10:13:04 dfr Exp $
|
|
*/
|
|
|
|
#ifndef _PCI_AGPVAR_H_
|
|
#define _PCI_AGPVAR_H_
|
|
|
|
#include <sys/lock.h>
|
|
|
|
struct agpbus_attach_args {
|
|
char *apa_busname;
|
|
struct pci_attach_args apa_pci_args;
|
|
};
|
|
|
|
/*
|
|
* The AGP chipset can be acquired by user or kernel code. If the
|
|
* chipset has already been acquired, it cannot be acquired by another
|
|
* user until the previous user has released it.
|
|
*/
|
|
enum agp_acquire_state {
|
|
AGP_ACQUIRE_FREE,
|
|
AGP_ACQUIRE_USER,
|
|
AGP_ACQUIRE_KERNEL
|
|
};
|
|
|
|
/*
|
|
* This structure is used to query the state of the AGP system.
|
|
*/
|
|
struct agp_info {
|
|
u_int32_t ai_mode;
|
|
bus_addr_t ai_aperture_base;
|
|
bus_size_t ai_aperture_size;
|
|
vsize_t ai_memory_allowed;
|
|
vsize_t ai_memory_used;
|
|
u_int32_t ai_devid;
|
|
};
|
|
|
|
struct agp_memory_info {
|
|
vsize_t ami_size; /* size in bytes */
|
|
bus_addr_t ami_physical; /* bogus hack for i810 */
|
|
off_t ami_offset; /* page offset if bound */
|
|
int ami_is_bound; /* non-zero if bound */
|
|
};
|
|
|
|
#define AGP_DEBUGxx
|
|
|
|
#ifdef AGP_DEBUG
|
|
#define AGP_DPF(x...) do { \
|
|
printf("agp: "); \
|
|
printf(##x); \
|
|
} while (0)
|
|
#else
|
|
#define AGP_DPF(x...) do {} while (0)
|
|
#endif
|
|
|
|
#define AGPUNIT(x) minor(x)
|
|
|
|
/*
|
|
* Data structure to describe an AGP memory allocation.
|
|
*/
|
|
TAILQ_HEAD(agp_memory_list, agp_memory);
|
|
struct agp_memory {
|
|
TAILQ_ENTRY(agp_memory) am_link; /* wiring for the tailq */
|
|
int am_id; /* unique id for block */
|
|
vsize_t am_size; /* number of bytes allocated */
|
|
int am_type; /* chipset specific type */
|
|
off_t am_offset; /* page offset if bound */
|
|
int am_is_bound; /* non-zero if bound */
|
|
bus_addr_t am_physical;
|
|
caddr_t am_virtual;
|
|
bus_dmamap_t am_dmamap;
|
|
bus_dma_segment_t *am_dmaseg;
|
|
int am_nseg;
|
|
};
|
|
|
|
struct agp_softc;
|
|
|
|
struct agp_methods {
|
|
u_int32_t (*get_aperture)(struct agp_softc *);
|
|
int (*set_aperture)(struct agp_softc *, u_int32_t);
|
|
int (*bind_page)(struct agp_softc *, off_t, bus_addr_t);
|
|
int (*unbind_page)(struct agp_softc *, off_t);
|
|
void (*flush_tlb)(struct agp_softc *);
|
|
int (*enable)(struct agp_softc *, u_int32_t mode);
|
|
struct agp_memory *(*alloc_memory)(struct agp_softc *, int, vsize_t);
|
|
int (*free_memory)(struct agp_softc *, struct agp_memory *);
|
|
int (*bind_memory)(struct agp_softc *, struct agp_memory *, off_t);
|
|
int (*unbind_memory)(struct agp_softc *, struct agp_memory *);
|
|
};
|
|
|
|
#define AGP_GET_APERTURE(sc) ((sc)->as_methods->get_aperture(sc))
|
|
#define AGP_SET_APERTURE(sc,a) ((sc)->as_methods->set_aperture((sc),(a)))
|
|
#define AGP_BIND_PAGE(sc,o,p) ((sc)->as_methods->bind_page((sc),(o),(p)))
|
|
#define AGP_UNBIND_PAGE(sc,o) ((sc)->as_methods->unbind_page((sc), (o)))
|
|
#define AGP_FLUSH_TLB(sc) ((sc)->as_methods->flush_tlb(sc))
|
|
#define AGP_ENABLE(sc,m) ((sc)->as_methods->enable((sc),(m)))
|
|
#define AGP_ALLOC_MEMORY(sc,t,s) ((sc)->as_methods->alloc_memory((sc),(t),(s)))
|
|
#define AGP_FREE_MEMORY(sc,m) ((sc)->as_methods->free_memory((sc),(m)))
|
|
#define AGP_BIND_MEMORY(sc,m,o) ((sc)->as_methods->bind_memory((sc),(m),(o)))
|
|
#define AGP_UNBIND_MEMORY(sc,m) ((sc)->as_methods->unbind_memory((sc),(m)))
|
|
|
|
/*
|
|
* All chipset drivers must have this at the start of their softc.
|
|
*/
|
|
struct agp_softc {
|
|
struct device as_dev;
|
|
bus_space_tag_t as_apt;
|
|
int as_capoff;
|
|
bus_addr_t as_apaddr;
|
|
bus_size_t as_apsize;
|
|
int as_apflags;
|
|
bus_dma_tag_t as_dmat;
|
|
u_int32_t as_maxmem; /* allocation upper bound */
|
|
u_int32_t as_allocated; /* amount allocated */
|
|
enum agp_acquire_state as_state;
|
|
struct agp_memory_list as_memory; /* list of allocated memory */
|
|
int as_nextid; /* next memory block id */
|
|
int as_isopen; /* user device is open */
|
|
#if 0
|
|
dev_t as_devnode; /* from make_dev */
|
|
#endif
|
|
struct lock as_lock; /* lock for access to GATT */
|
|
struct agp_methods *as_methods; /* chipset-dependent API */
|
|
void *as_chipc; /* chipset-dependent state */
|
|
pci_chipset_tag_t as_pc;
|
|
pcitag_t as_tag;
|
|
pcireg_t as_id;
|
|
};
|
|
|
|
struct agp_gatt {
|
|
u_int32_t ag_entries;
|
|
u_int32_t *ag_virtual;
|
|
bus_addr_t ag_physical;
|
|
bus_dmamap_t ag_dmamap;
|
|
bus_dma_segment_t ag_dmaseg;
|
|
size_t ag_size;
|
|
};
|
|
|
|
/*
|
|
* Functions private to the AGP code.
|
|
*/
|
|
void agp_flush_cache(void);
|
|
int agp_find_caps(pci_chipset_tag_t pct, pcitag_t pt);
|
|
int agp_map_aperture(struct pci_attach_args *pa, struct agp_softc *sc);
|
|
struct agp_gatt *agp_alloc_gatt(struct agp_softc *sc);
|
|
void agp_free_gatt(struct agp_softc *sc, struct agp_gatt *gatt);
|
|
int agp_generic_attach(struct agp_softc *sc);
|
|
int agp_generic_detach(struct agp_softc *sc);
|
|
int agp_generic_enable(struct agp_softc *sc, u_int32_t mode);
|
|
struct agp_memory *agp_generic_alloc_memory(struct agp_softc *sc, int type,
|
|
vsize_t size);
|
|
int agp_generic_free_memory(struct agp_softc *sc, struct agp_memory *mem);
|
|
int agp_generic_bind_memory(struct agp_softc *sc, struct agp_memory *mem,
|
|
off_t offset);
|
|
int agp_generic_unbind_memory(struct agp_softc *sc, struct agp_memory *mem);
|
|
|
|
/* The vendor has already been matched when these functions are called */
|
|
int agp_amd_match(const struct pci_attach_args *);
|
|
|
|
int agp_ali_attach(struct device *parent, struct device *self, void *aux);
|
|
int agp_amd_attach(struct device *parent, struct device *self, void *aux);
|
|
int agp_i810_attach(struct device *parent, struct device *self, void *aux);
|
|
int agp_intel_attach(struct device *parent, struct device *self, void *aux);
|
|
int agp_via_attach(struct device *parent, struct device *self, void *aux);
|
|
int agp_sis_attach(struct device *parent, struct device *self, void *aux);
|
|
|
|
int agp_alloc_dmamem(bus_dma_tag_t, size_t, int, bus_dmamap_t *, caddr_t *,
|
|
bus_addr_t *, bus_dma_segment_t *, int, int *);
|
|
void agp_free_dmamem(bus_dma_tag_t tag, size_t size, bus_dmamap_t map,
|
|
caddr_t vaddr, bus_dma_segment_t *seg, int nseg) ;
|
|
|
|
/*
|
|
* Kernel API
|
|
*/
|
|
/*
|
|
* Find the AGP device and return it.
|
|
*/
|
|
void *agp_find_device(int);
|
|
|
|
/*
|
|
* Return the current owner of the AGP chipset.
|
|
*/
|
|
enum agp_acquire_state agp_state(void *devcookie);
|
|
|
|
/*
|
|
* Query the state of the AGP system.
|
|
*/
|
|
void agp_get_info(void *devhandle, struct agp_info *info);
|
|
|
|
/*
|
|
* Acquire the AGP chipset for use by the kernel. Returns EBUSY if the
|
|
* AGP chipset is already acquired by another user.
|
|
*/
|
|
int agp_acquire(void *devhandle);
|
|
|
|
/*
|
|
* Release the AGP chipset.
|
|
*/
|
|
int agp_release(void *devhandle);
|
|
|
|
/*
|
|
* Enable the agp hardware with the relavent mode. The mode bits are
|
|
* defined in <dev/pci/agpreg.h>
|
|
*/
|
|
int agp_enable(void *devhandle, u_int32_t mode);
|
|
|
|
/*
|
|
* Allocate physical memory suitable for mapping into the AGP
|
|
* aperture. The value returned is an opaque handle which can be
|
|
* passed to agp_bind(), agp_unbind() or agp_deallocate().
|
|
*/
|
|
void *agp_alloc_memory(void *devhandle, int type, vsize_t bytes);
|
|
|
|
/*
|
|
* Free memory which was allocated with agp_allocate().
|
|
*/
|
|
void agp_free_memory(void *devhandle, void *handle);
|
|
|
|
/*
|
|
* Bind memory allocated with agp_allocate() at a given offset within
|
|
* the AGP aperture. Returns EINVAL if the memory is already bound or
|
|
* the offset is not at an AGP page boundary.
|
|
*/
|
|
int agp_bind_memory(void *devhandle, void *handle, off_t offset);
|
|
|
|
/*
|
|
* Unbind memory from the AGP aperture. Returns EINVAL if the memory
|
|
* is not bound.
|
|
*/
|
|
int agp_unbind_memory(void *devhandle, void *handle);
|
|
|
|
/*
|
|
* Retrieve information about a memory block allocated with
|
|
* agp_alloc_memory().
|
|
*/
|
|
void agp_memory_info(void *devhandle, void *handle, struct agp_memory_info *mi);
|
|
|
|
#endif /* !_PCI_AGPPRIV_H_ */
|