NetBSD/sys/dev/pci/agpvar.h

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_ */