/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright (c) 2009, Intel Corporation.
* All Rights Reserved.
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Misc module for AGP master device support
*/
#include <sys/modctl.h>
#include <sys/pci.h>
#include <sys/stat.h>
#include <sys/file.h>
#include <sys/types.h>
#include <sys/dditypes.h>
#include <sys/sunddi.h>
#include <sys/agpgart.h>
#include <sys/agp/agpdefs.h>
#include <sys/agp/agpmaster_io.h>
#define PGTBL_CTL 0x2020 /* Page table control register */
#define I8XX_FB_BAR 1
#define I8XX_MMIO_BAR 2
#define I8XX_PTE_OFFSET 0x10000
#define I915_MMADR 1 /* mem-mapped registers BAR */
#define I915_GMADR 3 /* graphics mem BAR */
#define I915_GTTADDR 4 /* GTT BAR */
#define I965_GTTMMADR 1 /* mem-mapped registers BAR + GTT */
/* In 965 1MB GTTMMADR, GTT reside in the latter 512KB */
#define I965_GTT_OFFSET 0x80000
#define GM45_GTT_OFFSET 0x200000
#define GTT_SIZE_MASK 0xe
#define GTT_512KB (0 << 1)
#define GTT_256KB (1 << 1)
#define GTT_128KB (2 << 1)
#define GTT_1MB (3 << 1)
#define GTT_2MB (4 << 1)
#define GTT_1_5MB (5 << 1)
#define MMIO_BASE(x) (x)->agpm_data.agpm_gtt.gtt_mmio_base
#define MMIO_HANDLE(x) (x)->agpm_data.agpm_gtt.gtt_mmio_handle
#define GTT_HANDLE(x) (x)->agpm_data.agpm_gtt.gtt_handle
/* Base address of GTT */
#define GTT_ADDR(x) (x)->agpm_data.agpm_gtt.gtt_addr
/* Graphics memory base address */
#define APER_BASE(x) (x)->agpm_data.agpm_gtt.gtt_info.igd_aperbase
#define AGPM_WRITE(x, off, val) \
ddi_put32(MMIO_HANDLE(x), (uint32_t *)(MMIO_BASE(x) + (off)), (val));
#define AGPM_READ(x, off) \
ddi_get32(MMIO_HANDLE(x), (uint32_t *)(MMIO_BASE(x) + (off)));
#ifdef DEBUG
#define CONFIRM(value) ASSERT(value)
#else
#define CONFIRM(value) if (!(value)) return (EINVAL)
#endif
int agpm_debug = 0;
#define AGPM_DEBUG(args) if (agpm_debug >= 1) cmn_err args
/*
* Whether it is a Intel integrated graphics card
*/
#define IS_IGD(agpmaster) ((agpmaster->agpm_dev_type == DEVICE_IS_I810) || \
(agpmaster->agpm_dev_type == DEVICE_IS_I830))
static struct modlmisc modlmisc = {
&mod_miscops, "AGP master interfaces"
};
static struct modlinkage modlinkage = {
MODREV_1, (void *)&modlmisc, NULL
};
static ddi_device_acc_attr_t i8xx_dev_access = {
DDI_DEVICE_ATTR_V0,
DDI_NEVERSWAP_ACC,
DDI_STRICTORDER_ACC
};
static off_t agpmaster_cap_find(ddi_acc_handle_t);
static int detect_i8xx_device(agp_master_softc_t *);
static int detect_agp_devcice(agp_master_softc_t *, ddi_acc_handle_t);
static int i8xx_add_to_gtt(gtt_impl_t *, igd_gtt_seg_t);
static void i8xx_remove_from_gtt(gtt_impl_t *, igd_gtt_seg_t);
int
_init(void)
{
int err;
if ((err = mod_install(&modlinkage)) != 0)
return (err);
return (0);
}
int
_fini(void)
{
int err;
if ((err = mod_remove(&modlinkage)) != 0)
return (err);
return (0);
}
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
/*
* Minor node is not removed here, since the caller (xx_attach) is
* responsible for removing all nodes.
*/
void
agpmaster_detach(agp_master_softc_t **master_softcp)
{
agp_master_softc_t *master_softc;
ASSERT(master_softcp);
master_softc = *master_softcp;
/* intel integrated device */
if (IS_IGD(master_softc) &&
((MMIO_HANDLE(master_softc) != NULL) ||
(GTT_HANDLE(master_softc) != NULL))) {
/*
* for some chipsets, mmap handle is shared between both mmio
* and GTT table.
*/
if ((GTT_HANDLE(master_softc) != MMIO_HANDLE(master_softc)) &&
(GTT_HANDLE(master_softc) != NULL))
ddi_regs_map_free(&GTT_HANDLE(master_softc));
if (MMIO_HANDLE(master_softc) != NULL)
ddi_regs_map_free(&MMIO_HANDLE(master_softc));
}
kmem_free(master_softc, sizeof (agp_master_softc_t));
master_softc = NULL;
return;
}
/*
* 965 has a fixed GTT table size (512KB), so check to see the actual aperture
* size. Aperture size = GTT table size * 1024.
*/
static off_t
i965_apersize(agp_master_softc_t *agpmaster)
{
off_t apersize;
apersize = AGPM_READ(agpmaster, PGTBL_CTL);
AGPM_DEBUG((CE_NOTE, "i965_apersize: PGTBL_CTL = %lx", apersize));
switch (apersize & GTT_SIZE_MASK) {
case GTT_2MB:
apersize = 2048;
break;
case GTT_1_5MB:
apersize = 1536;
break;
case GTT_1MB:
apersize = 1024;
break;
case GTT_512KB:
apersize = 512;
break;
case GTT_256KB:
apersize = 256;
break;
case GTT_128KB:
apersize = 128;
break;
default:
apersize = 0;
AGPM_DEBUG((CE_WARN,
"i965_apersize: invalid GTT size in PGTBL_CTL"));
}
return (apersize);
}
/*
* For Intel 3 series, we need to get GTT size from the GGMS field in GMCH
* Graphics Control Register. Return aperture size in MB.
*/
static off_t
i3XX_apersize(ddi_acc_handle_t pci_acc_hdl)
{
uint16_t value;
off_t apersize;
/*
* Get the value of configuration register MGGC "Mirror of Dev0 GMCH
* Graphics Control" from Internal Graphics #2 (Device2:Function0).
*/
value = pci_config_get16(pci_acc_hdl, I8XX_CONF_GC);
AGPM_DEBUG((CE_NOTE, "i3XX_apersize: MGGC = 0x%x", value));
/* computing aperture size using the pre-allocated GTT size */
switch (value & IX33_GGMS_MASK) {
case IX33_GGMS_1M:
apersize = 1024;
break;
case IX33_GGMS_2M:
apersize = 2048;
break;
default:
apersize = 0; /* no memory pre-allocated */
AGPM_DEBUG((CE_WARN,
"i3XX_apersize: no memory allocated for GTT"));
}
AGPM_DEBUG((CE_NOTE, "i3xx_apersize: apersize = %ldM", apersize));
return (apersize);
}
#define CHECK_STATUS(status) \
if (status != DDI_SUCCESS) { \
AGPM_DEBUG((CE_WARN, \
"set_gtt_mmio: regs_map_setup error")); \
return (-1); \
}
/*
* Set gtt_addr, gtt_mmio_base, igd_apersize, igd_aperbase and igd_devid
* according to chipset.
*/
static int
set_gtt_mmio(dev_info_t *devi, agp_master_softc_t *agpmaster,
ddi_acc_handle_t pci_acc_hdl)
{
off_t apersize; /* size of graphics mem (MB) == GTT size (KB) */
uint32_t value;
off_t gmadr_off; /* GMADR offset in PCI config space */
int status;
if (IS_INTEL_X33(agpmaster->agpm_id)) {
/* Intel 3 series are similar with 915/945 series */
status = ddi_regs_map_setup(devi, I915_GTTADDR,
&GTT_ADDR(agpmaster), 0, 0, &i8xx_dev_access,
&GTT_HANDLE(agpmaster));
CHECK_STATUS(status);
status = ddi_regs_map_setup(devi, I915_MMADR,
&MMIO_BASE(agpmaster), 0, 0, &i8xx_dev_access,
&MMIO_HANDLE(agpmaster));
CHECK_STATUS(status);
gmadr_off = I915_CONF_GMADR;
/* Different computing method used in getting aperture size. */
apersize = i3XX_apersize(pci_acc_hdl);
} else if (IS_INTEL_965(agpmaster->agpm_id)) {
status = ddi_regs_map_setup(devi, I965_GTTMMADR,
&MMIO_BASE(agpmaster), 0, 0, &i8xx_dev_access,
&MMIO_HANDLE(agpmaster));
CHECK_STATUS(status);
if ((agpmaster->agpm_id == INTEL_IGD_GM45) ||
IS_INTEL_G4X(agpmaster->agpm_id))
GTT_ADDR(agpmaster) =
MMIO_BASE(agpmaster) + GM45_GTT_OFFSET;
else
GTT_ADDR(agpmaster) =
MMIO_BASE(agpmaster) + I965_GTT_OFFSET;
GTT_HANDLE(agpmaster) = MMIO_HANDLE(agpmaster);
gmadr_off = I915_CONF_GMADR;
apersize = i965_apersize(agpmaster);
} else if (IS_INTEL_915(agpmaster->agpm_id)) {
/* I915/945 series */
status = ddi_regs_map_setup(devi, I915_GTTADDR,
&GTT_ADDR(agpmaster), 0, 0, &i8xx_dev_access,
&GTT_HANDLE(agpmaster));
CHECK_STATUS(status);
status = ddi_regs_map_setup(devi, I915_MMADR,
&MMIO_BASE(agpmaster), 0, 0, &i8xx_dev_access,
&MMIO_HANDLE(agpmaster));
CHECK_STATUS(status);
gmadr_off = I915_CONF_GMADR;
status = ddi_dev_regsize(devi, I915_GMADR, &apersize);
apersize = BYTES2MB(apersize);
} else {
/* I8XX series */
status = ddi_regs_map_setup(devi, I8XX_MMIO_BAR,
&MMIO_BASE(agpmaster), 0, 0, &i8xx_dev_access,
&MMIO_HANDLE(agpmaster));
CHECK_STATUS(status);
GTT_ADDR(agpmaster) = MMIO_BASE(agpmaster) + I8XX_PTE_OFFSET;
GTT_HANDLE(agpmaster) = MMIO_HANDLE(agpmaster);
gmadr_off = I8XX_CONF_GMADR;
status = ddi_dev_regsize(devi, I8XX_FB_BAR, &apersize);
apersize = BYTES2MB(apersize);
CHECK_STATUS(status);
}
/*
* If memory size is smaller than a certain value, it means
* the register set number for graphics memory range might
* be wrong
*/
if (status != DDI_SUCCESS || apersize < 4) {
AGPM_DEBUG((CE_WARN,
"set_gtt_mmio: error in getting graphics memory"));
return (-1);
}
agpmaster->agpm_data.agpm_gtt.gtt_info.igd_apersize = apersize;
/* get graphics memory base address from GMADR */
value = pci_config_get32(pci_acc_hdl, gmadr_off);
APER_BASE(agpmaster) = value & GTT_BASE_MASK;
AGPM_DEBUG((CE_NOTE, "set_gtt_mmio: aperbase = 0x%x, apersize = %ldM, "
"gtt_addr = %p, mmio_base = %p", APER_BASE(agpmaster), apersize,
(void *)GTT_ADDR(agpmaster), (void *)MMIO_BASE(agpmaster)));
return (0);
}
/*
* Try to initialize agp master.
* 0 is returned if the device is successfully initialized. AGP master soft
* state is returned in master_softcp if needed.
* Otherwise -1 is returned and *master_softcp is set to NULL.
*/
int
agpmaster_attach(dev_info_t *devi, agp_master_softc_t **master_softcp,
ddi_acc_handle_t pci_acc_hdl, minor_t minor)
{
int instance;
int status;
agp_master_softc_t *agpmaster;
char buf[80];
ASSERT(pci_acc_hdl);
*master_softcp = NULL;
agpmaster = (agp_master_softc_t *)
kmem_zalloc(sizeof (agp_master_softc_t), KM_SLEEP);
agpmaster->agpm_id =
pci_config_get32(pci_acc_hdl, PCI_CONF_VENID);
agpmaster->agpm_acc_hdl = pci_acc_hdl;
if (!detect_i8xx_device(agpmaster)) {
/* Intel 8XX, 915, 945 and 965 series */
if (set_gtt_mmio(devi, agpmaster, pci_acc_hdl) != 0)
goto fail;
} else if (detect_agp_devcice(agpmaster, pci_acc_hdl)) {
/* non IGD or AGP devices, AMD64 gart */
AGPM_DEBUG((CE_WARN,
"agpmaster_attach: neither IGD or AGP devices exists"));
agpmaster_detach(&agpmaster);
return (0);
}
agpmaster->agpm_data.agpm_gtt.gtt_info.igd_devid =
agpmaster->agpm_id;
/* create minor node for IGD or AGP device */
instance = ddi_get_instance(devi);
(void) sprintf(buf, "%s%d", AGPMASTER_NAME, instance);
status = ddi_create_minor_node(devi, buf, S_IFCHR, minor,
DDI_NT_AGP_MASTER, 0);
if (status != DDI_SUCCESS) {
AGPM_DEBUG((CE_WARN,
"agpmaster_attach: create agpmaster node failed"));
goto fail;
}
*master_softcp = agpmaster;
return (0);
fail:
agpmaster_detach(&agpmaster);
return (-1);
}
/*
* Currently, it handles ioctl requests related with agp master device for
* layered driver (agpgart) only.
*/
/*ARGSUSED*/
int
agpmaster_ioctl(dev_t dev, int cmd, intptr_t data, int mode, cred_t *cred,
int *rval, agp_master_softc_t *softc)
{
uint32_t base;
uint32_t addr;
igd_gtt_seg_t seg;
agp_info_t info;
uint32_t value;
off_t cap;
uint32_t command;
static char kernel_only[] =
"agpmaster_ioctl: %s is a kernel only ioctl";
CONFIRM(softc);
switch (cmd) {
case DEVICE_DETECT:
if (!(mode & FKIOCTL)) {
AGPM_DEBUG((CE_CONT, kernel_only, "DEVICE_DETECT"));
return (ENXIO);
}
if (ddi_copyout(&softc->agpm_dev_type,
(void *)data, sizeof (int), mode))
return (EFAULT);
break;
case AGP_MASTER_SETCMD:
if (!(mode & FKIOCTL)) {
AGPM_DEBUG((CE_CONT, kernel_only, "AGP_MASTER_SETCMD"));
return (ENXIO);
}
CONFIRM(softc->agpm_dev_type == DEVICE_IS_AGP);
CONFIRM(softc->agpm_data.agpm_acaptr);
if (ddi_copyin((void *)data, &command,
sizeof (uint32_t), mode))
return (EFAULT);
pci_config_put32(softc->agpm_acc_hdl,
softc->agpm_data.agpm_acaptr + AGP_CONF_COMMAND,
command);
break;
case AGP_MASTER_GETINFO:
if (!(mode & FKIOCTL)) {
AGPM_DEBUG((CE_CONT, kernel_only,
"AGP_MASTER_GETINFO"));
return (ENXIO);
}
CONFIRM(softc->agpm_dev_type == DEVICE_IS_AGP);
CONFIRM(softc->agpm_data.agpm_acaptr);
cap = softc->agpm_data.agpm_acaptr;
value = pci_config_get32(softc->agpm_acc_hdl, cap);
info.agpi_version.agpv_major = (uint16_t)((value >> 20) & 0xf);
info.agpi_version.agpv_minor = (uint16_t)((value >> 16) & 0xf);
info.agpi_devid = softc->agpm_id;
info.agpi_mode = pci_config_get32(
softc->agpm_acc_hdl, cap + AGP_CONF_STATUS);
if (ddi_copyout(&info, (void *)data,
sizeof (agp_info_t), mode))
return (EFAULT);
break;
case I810_SET_GTT_BASE:
if (!(mode & FKIOCTL)) {
AGPM_DEBUG((CE_CONT, kernel_only, "I810_SET_GTT_ADDR"));
return (ENXIO);
}
CONFIRM(softc->agpm_dev_type == DEVICE_IS_I810);
if (ddi_copyin((void *)data, &base, sizeof (uint32_t), mode))
return (EFAULT);
/* enables page table */
addr = (base & GTT_BASE_MASK) | GTT_TABLE_VALID;
AGPM_WRITE(softc, PGTBL_CTL, addr);
break;
case I8XX_GET_INFO:
if (!(mode & FKIOCTL)) {
AGPM_DEBUG((CE_CONT, kernel_only, "I8XX_GET_INFO"));
return (ENXIO);
}
CONFIRM(IS_IGD(softc));
if (ddi_copyout(&softc->agpm_data.agpm_gtt.gtt_info,
(void *)data, sizeof (igd_info_t), mode))
return (EFAULT);
break;
case I8XX_ADD2GTT:
if (!(mode & FKIOCTL)) {
AGPM_DEBUG((CE_CONT, kernel_only, "I8XX_ADD2GTT"));
return (ENXIO);
}
CONFIRM(IS_IGD(softc));
if (ddi_copyin((void *)data, &seg,
sizeof (igd_gtt_seg_t), mode))
return (EFAULT);
if (i8xx_add_to_gtt(&softc->agpm_data.agpm_gtt, seg))
return (EINVAL);
break;
case I8XX_REM_GTT:
if (!(mode & FKIOCTL)) {
AGPM_DEBUG((CE_CONT, kernel_only, "I8XX_REM_GTT"));
return (ENXIO);
}
CONFIRM(IS_IGD(softc));
if (ddi_copyin((void *)data, &seg,
sizeof (igd_gtt_seg_t), mode))
return (EFAULT);
i8xx_remove_from_gtt(&softc->agpm_data.agpm_gtt, seg);
break;
case I8XX_UNCONFIG:
if (!(mode & FKIOCTL)) {
AGPM_DEBUG((CE_CONT, kernel_only, "I8XX_UNCONFIG"));
return (ENXIO);
}
CONFIRM(IS_IGD(softc));
if (softc->agpm_dev_type == DEVICE_IS_I810)
AGPM_WRITE(softc, PGTBL_CTL, 0);
/*
* may need to clear all gtt entries here for i830 series,
* but may not be necessary
*/
break;
}
return (0);
}
/*
* If AGP cap pointer is successfully found, none-zero value is returned.
* Otherwise 0 is returned.
*/
static off_t
agpmaster_cap_find(ddi_acc_handle_t acc_handle)
{
off_t nextcap;
uint32_t ncapid;
uint8_t value;
/* check if this device supports capibility pointer */
value = (uint8_t)(pci_config_get16(acc_handle, PCI_CONF_STAT)
& PCI_CONF_CAP_MASK);
if (!value)
return (0);
/* get the offset of the first capability pointer from CAPPTR */
nextcap = (off_t)(pci_config_get8(acc_handle, AGP_CONF_CAPPTR));
/* check AGP capability from the first capability pointer */
while (nextcap) {
ncapid = pci_config_get32(acc_handle, nextcap);
if ((ncapid & PCI_CONF_CAPID_MASK)
== AGP_CAP_ID) /* find AGP cap */
break;
nextcap = (off_t)((ncapid & PCI_CONF_NCAPID_MASK) >> 8);
}
return (nextcap);
}
/*
* If i8xx device is successfully detected, 0 is returned.
* Otherwise -1 is returned.
*/
static int
detect_i8xx_device(agp_master_softc_t *master_softc)
{
switch (master_softc->agpm_id) {
case INTEL_IGD_810:
case INTEL_IGD_810DC:
case INTEL_IGD_810E:
case INTEL_IGD_815:
master_softc->agpm_dev_type = DEVICE_IS_I810;
break;
case INTEL_IGD_830M:
case INTEL_IGD_845G:
case INTEL_IGD_855GM:
case INTEL_IGD_865G:
case INTEL_IGD_915:
case INTEL_IGD_915GM:
case INTEL_IGD_945:
case INTEL_IGD_945GM:
case INTEL_IGD_945GME:
case INTEL_IGD_946GZ:
case INTEL_IGD_965G1:
case INTEL_IGD_965G2:
case INTEL_IGD_965GM:
case INTEL_IGD_965GME:
case INTEL_IGD_965Q:
case INTEL_IGD_Q35:
case INTEL_IGD_G33:
case INTEL_IGD_Q33:
case INTEL_IGD_GM45:
case INTEL_IGD_EL:
case INTEL_IGD_Q45:
case INTEL_IGD_G45:
case INTEL_IGD_G41:
case INTEL_IGD_IGDNG_D:
case INTEL_IGD_IGDNG_M:
case INTEL_IGD_B43:
master_softc->agpm_dev_type = DEVICE_IS_I830;
break;
default: /* unknown id */
return (-1);
}
return (0);
}
/*
* If agp master is successfully detected, 0 is returned.
* Otherwise -1 is returned.
*/
static int
detect_agp_devcice(agp_master_softc_t *master_softc,
ddi_acc_handle_t acc_handle)
{
off_t cap;
cap = agpmaster_cap_find(acc_handle);
if (cap) {
master_softc->agpm_dev_type = DEVICE_IS_AGP;
master_softc->agpm_data.agpm_acaptr = cap;
return (0);
} else {
return (-1);
}
}
/*
* Please refer to GART and GTT entry format table in agpdefs.h for
* intel GTT entry format.
*/
static int
phys2entry(uint32_t type, uint32_t physaddr, uint32_t *entry)
{
uint32_t value;
switch (type) {
case AGP_PHYSICAL:
case AGP_NORMAL:
value = (physaddr & GTT_PTE_MASK) | GTT_PTE_VALID;
break;
default:
return (-1);
}
*entry = value;
return (0);
}
static int
i8xx_add_to_gtt(gtt_impl_t *gtt, igd_gtt_seg_t seg)
{
int i;
uint32_t *paddr;
uint32_t entry;
uint32_t maxpages;
maxpages = gtt->gtt_info.igd_apersize;
maxpages = GTT_MB_TO_PAGES(maxpages);
paddr = seg.igs_phyaddr;
/* check if gtt max page number is reached */
if ((seg.igs_pgstart + seg.igs_npage) > maxpages)
return (-1);
paddr = seg.igs_phyaddr;
for (i = seg.igs_pgstart; i < (seg.igs_pgstart + seg.igs_npage);
i++, paddr++) {
if (phys2entry(seg.igs_type, *paddr, &entry))
return (-1);
ddi_put32(gtt->gtt_handle,
(uint32_t *)(gtt->gtt_addr + i * sizeof (uint32_t)),
entry);
}
return (0);
}
static void
i8xx_remove_from_gtt(gtt_impl_t *gtt, igd_gtt_seg_t seg)
{
int i;
uint32_t maxpages;
maxpages = gtt->gtt_info.igd_apersize;
maxpages = GTT_MB_TO_PAGES(maxpages);
/* check if gtt max page number is reached */
if ((seg.igs_pgstart + seg.igs_npage) > maxpages)
return;
for (i = seg.igs_pgstart; i < (seg.igs_pgstart + seg.igs_npage); i++) {
ddi_put32(gtt->gtt_handle,
(uint32_t *)(gtt->gtt_addr + i * sizeof (uint32_t)), 0);
}
}