void
VIAUnmapMem(ScrnInfoPtr pScrn)
{
VIAPtr pVia = VIAPTR(pScrn);
DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VIAUnmapMem\n"));
ViaMMIODisable(pScrn);
#ifdef HAVE_PCIACCESS
if (pVia->MapBase)
pci_device_unmap_range(pVia->PciInfo, (pointer) pVia->MapBase,
VIA_MMIO_REGSIZE);
if (pVia->BltBase)
pci_device_unmap_range(pVia->PciInfo, (pointer) pVia->BltBase,
VIA_MMIO_BLTSIZE);
if (pVia->FBBase)
pci_device_unmap_range(pVia->PciInfo, (pointer) pVia->FBBase,
pVia->videoRambytes);
#else
if (pVia->MapBase)
xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pVia->MapBase,
VIA_MMIO_REGSIZE);
if (pVia->BltBase)
xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pVia->BltBase,
VIA_MMIO_BLTSIZE);
if (pVia->FBBase)
xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pVia->FBBase,
pVia->videoRambytes);
#endif
}
/*
* xf86ReadDomainMemory - copy from domain memory into a caller supplied buffer
*/
int
xf86ReadDomainMemory(PCITAG Tag, ADDRESS Base, int Len, unsigned char *Buf)
{
unsigned char *ptr, *src;
ADDRESS offset;
unsigned long size;
int len, pagemask = getpagesize() - 1;
unsigned int i, dom, bus, dev, func;
unsigned int fd;
char file[256];
struct stat st;
dom = PCI_DOM_FROM_TAG(Tag);
bus = PCI_BUS_FROM_TAG(Tag);
dev = PCI_DEV_FROM_TAG(Tag);
func = PCI_FUNC_FROM_TAG(Tag);
sprintf(file, "/sys/devices/pci%04x:%02x/%04x:%02x:%02x.%1x/rom",
dom, bus, dom, bus, dev, func);
/*
* If the caller wants the ROM and the sysfs rom interface exists,
* try to use it instead of reading it from /proc/bus/pci.
*/
if (((Base & 0xfffff) == 0xC0000) && (stat(file, &st) == 0)) {
if ((fd = open(file, O_RDWR)))
Base = 0x0;
/* enable the ROM first */
write(fd, "1", 2);
lseek(fd, 0, SEEK_SET);
/* copy the ROM until we hit Len, EOF or read error */
for (i = 0; i < Len && read(fd, Buf, 1) > 0; Buf++, i++)
;
write(fd, "0", 2);
close(fd);
return Len;
}
/* Ensure page boundaries */
offset = Base & ~pagemask;
size = ((Base + Len + pagemask) & ~pagemask) - offset;
ptr = xf86MapDomainMemory(-1, VIDMEM_READONLY, Tag, offset, size);
if (!ptr)
return -1;
/* Using memcpy() here can hang the system */
src = ptr + (Base - offset);
for (len = Len; len-- > 0;)
*Buf++ = *src++;
xf86UnMapVidMem(-1, ptr, size);
return Len;
}
Bool
CirUnmapMem(CirPtr pCir, int scrnIndex)
{
#ifdef CIR_DEBUG
ErrorF("CirUnmapMem\n");
#endif
if (pCir->IOBase != NULL) {
/*
* Unmap IO registers to virtual address space
*/
xf86UnMapVidMem(scrnIndex, (pointer)pCir->IOBase, pCir->IoMapSize);
pCir->IOBase = NULL;
}
xf86UnMapVidMem(scrnIndex, (pointer)pCir->FbBase, pCir->FbMapSize);
pCir->FbBase = NULL;
return TRUE;
}
void
ASTUnmapMMIO(ScrnInfoPtr pScrn)
{
ASTRecPtr pAST = ASTPTR(pScrn);
#ifndef XSERVER_LIBPCIACCESS
xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pAST->MMIOVirtualAddr,
pAST->MMIOMapSize);
#else
pci_device_unmap_range(pAST->PciInfo, pAST->MMIOVirtualAddr, pAST->MMIOMapSize);
#endif
pAST->MMIOVirtualAddr = 0;
}
_X_EXPORT void
xf86UnmapSbusMem(sbusDevicePtr psdp, pointer Base, unsigned long Size)
{
xf86UnMapVidMem(0, Base, Size);
}
int
Permedia3MemorySizeDetect(ScrnInfoPtr pScrn)
{
GLINTPtr pGlint = GLINTPTR (pScrn);
CARD32 size = 0, temp, temp1, temp2, i;
/* We can map 64MB, as that's the size of the Permedia3 aperture
* regardless of memory configuration */
pGlint->FbMapSize = 64*1024*1024;
#ifndef XSERVER_LIBPCIACCESS
/* Mark as VIDMEM_MMIO to avoid write-combining while detecting memory */
pGlint->FbBase = xf86MapPciMem(pScrn->scrnIndex, VIDMEM_MMIO,
pGlint->PciTag, pGlint->FbAddress, pGlint->FbMapSize);
#else
{
void** result = (void**)&pGlint->FbBase;
int err = pci_device_map_range(pGlint->PciInfo,
pGlint->FbAddress,
pGlint->FbMapSize,
PCI_DEV_MAP_FLAG_WRITABLE,
result);
if (err)
return FALSE;
}
#endif
if (pGlint->FbBase == NULL)
return 0;
temp = GLINT_READ_REG(PM3MemBypassWriteMask);
GLINT_SLOW_WRITE_REG(0xffffffff, PM3MemBypassWriteMask);
/* The Permedia3 splits up memory, and even replicates it. Grrr.
* So that each 32MB appears at offset 0, and offset 32, unless
* there's really 64MB attached to the chip.
* So, 16MB appears at offset 0, nothing between 16-32, then it re-appears
* at offset 32.
* This below is to detect the cases of memory combinations
*/
/* Test first 32MB */
for(i=0;i<32;i++) {
/* write test pattern */
MMIO_OUT32(pGlint->FbBase, i*1024*1024, i*0x00345678);
mem_barrier();
temp1 = MMIO_IN32(pGlint->FbBase, i*1024*1024);
/* Let's check for wrapover, write will fail at 16MB boundary */
if (temp1 == (i*0x00345678))
size = i;
else
break;
}
/* Ok, we're satisfied we've got 32MB, let's test the second lot */
if ((size + 1) == i) {
for(i=0;i<32;i++) {
/* Clear first 32MB */
MMIO_OUT32(pGlint->FbBase, i*1024*1024, 0);
}
mem_barrier();
for(i=32;i<64;i++) {
/* write test pattern */
MMIO_OUT32(pGlint->FbBase, i*1024*1024, i*0x00345678);
mem_barrier();
temp1 = MMIO_IN32(pGlint->FbBase, i*1024*1024);
temp2 = MMIO_IN32(pGlint->FbBase, (i-32)*1024*1024);
/* Let's check for wrapover */
if ( (temp1 == (i*0x00345678)) && (temp2 == 0) )
size = i;
else
break;
}
}
GLINT_SLOW_WRITE_REG(temp, PM3MemBypassWriteMask);
#ifndef XSERVER_LIBPCIACCESS
xf86UnMapVidMem(pScrn->scrnIndex, (pointer)pGlint->FbBase,
pGlint->FbMapSize);
#else
pci_device_unmap_range(pGlint->PciInfo, pGlint->FbBase, pGlint->FbMapSize);
#endif
pGlint->FbBase = NULL;
pGlint->FbMapSize = 0;
return ( (size+1) * 1024 );
}
static Bool
VIAMapFB(ScrnInfoPtr pScrn)
{
VIAPtr pVia = VIAPTR(pScrn);
#ifdef HAVE_PCIACCESS
if (pVia->Chipset == VIA_VX900) {
pVia->FrameBufferBase = pVia->PciInfo->regions[2].base_addr;
} else {
pVia->FrameBufferBase = pVia->PciInfo->regions[0].base_addr;
}
int err;
#else
if (pVia->Chipset == VIA_VX900) {
pVia->FrameBufferBase = pVia->PciInfo->memBase[2];
} else {
pVia->FrameBufferBase = pVia->PciInfo->memBase[0];
}
#endif
DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VIAMapFB\n"));
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"mapping framebuffer @ 0x%lx with size 0x%lx\n",
pVia->FrameBufferBase, pVia->videoRambytes);
if (pVia->videoRambytes) {
#ifndef HAVE_PCIACCESS
/*
* FIXME: This is a hack to get rid of offending wrongly sized
* MTRR regions set up by the VIA BIOS. Should be taken care of
* in the OS support layer.
*/
unsigned char *tmp;
tmp = xf86MapPciMem(pScrn->scrnIndex, VIDMEM_MMIO, pVia->PciTag,
pVia->FrameBufferBase, pVia->videoRambytes);
xf86UnMapVidMem(pScrn->scrnIndex, (pointer) tmp, pVia->videoRambytes);
/*
* And, as if this wasn't enough, 2.6 series kernels don't
* remove MTRR regions on the first attempt. So try again.
*/
tmp = xf86MapPciMem(pScrn->scrnIndex, VIDMEM_MMIO, pVia->PciTag,
pVia->FrameBufferBase, pVia->videoRambytes);
xf86UnMapVidMem(pScrn->scrnIndex, (pointer) tmp, pVia->videoRambytes);
/*
* End of hack.
*/
#endif
#ifdef HAVE_PCIACCESS
err = pci_device_map_range(pVia->PciInfo, pVia->FrameBufferBase,
pVia->videoRambytes,
(PCI_DEV_MAP_FLAG_WRITABLE |
PCI_DEV_MAP_FLAG_WRITE_COMBINE),
(void **)&pVia->FBBase);
if (err) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Unable to map mmio BAR. %s (%d)\n", strerror(err), err);
return FALSE;
}
#else
pVia->FBBase = xf86MapPciMem(pScrn->scrnIndex, VIDMEM_FRAMEBUFFER,
pVia->PciTag, pVia->FrameBufferBase,
pVia->videoRambytes);
if (!pVia->FBBase) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Internal error: could not map framebuffer\n");
return FALSE;
}
#endif
pVia->FBFreeStart = 0;
pVia->FBFreeEnd = pVia->videoRambytes;
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Frame buffer start: %p, free start: 0x%x end: 0x%x\n",
pVia->FBBase, pVia->FBFreeStart, pVia->FBFreeEnd);
}
#ifdef HAVE_PCIACCESS
pScrn->memPhysBase = pVia->PciInfo->regions[0].base_addr;
#else
pScrn->memPhysBase = pVia->PciInfo->memBase[0];
#endif
pScrn->fbOffset = 0;
if (pVia->IsSecondary)
pScrn->fbOffset = pScrn->videoRam << 10;
return TRUE;
}
