aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/programs/Xserver/hw/xfree86/common/xf86Bus.c
diff options
context:
space:
mode:
authorMike Gabriel <mike.gabriel@das-netzwerkteam.de>2015-02-02 15:02:49 +0100
committerMike Gabriel <mike.gabriel@das-netzwerkteam.de>2015-02-02 15:02:49 +0100
commitb16b9e4656e7199c2aec74a4c8ebc7a875d3ba73 (patch)
tree4361edef0d42d5bf5ac984ef72b4fac35426eae7 /nx-X11/programs/Xserver/hw/xfree86/common/xf86Bus.c
parent0d5a83e986f39982c0924652a3662e60b1f23162 (diff)
downloadnx-libs-b16b9e4656e7199c2aec74a4c8ebc7a875d3ba73.tar.gz
nx-libs-b16b9e4656e7199c2aec74a4c8ebc7a875d3ba73.tar.bz2
nx-libs-b16b9e4656e7199c2aec74a4c8ebc7a875d3ba73.zip
massive reduction of unneeded files
Diffstat (limited to 'nx-X11/programs/Xserver/hw/xfree86/common/xf86Bus.c')
-rw-r--r--nx-X11/programs/Xserver/hw/xfree86/common/xf86Bus.c3317
1 files changed, 0 insertions, 3317 deletions
diff --git a/nx-X11/programs/Xserver/hw/xfree86/common/xf86Bus.c b/nx-X11/programs/Xserver/hw/xfree86/common/xf86Bus.c
deleted file mode 100644
index e0cc4dd65..000000000
--- a/nx-X11/programs/Xserver/hw/xfree86/common/xf86Bus.c
+++ /dev/null
@@ -1,3317 +0,0 @@
-/* $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86Bus.c,v 1.80 2004/02/05 18:24:59 eich Exp $ */
-/*
- * Copyright (c) 1997-2003 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-#define REDUCER
-/*
- * This file contains the interfaces to the bus-specific code
- */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <ctype.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <X11/X.h>
-#include "os.h"
-#include "xf86.h"
-#include "xf86Priv.h"
-#include "xf86Resources.h"
-
-/* Bus-specific headers */
-
-#include "xf86Bus.h"
-
-#define XF86_OS_PRIVS
-#define NEED_OS_RAC_PROTOS
-#include "xf86_OSproc.h"
-
-#include "xf86RAC.h"
-
-/* Entity data */
-EntityPtr *xf86Entities = NULL; /* Bus slots claimed by drivers */
-int xf86NumEntities = 0;
-static int xf86EntityPrivateCount = 0;
-BusAccPtr xf86BusAccInfo = NULL;
-
-xf86AccessRec AccessNULL = {NULL,NULL,NULL};
-
-xf86CurrentAccessRec xf86CurrentAccess = {NULL,NULL};
-
-BusRec primaryBus = { BUS_NONE, {{0}}};
-
-Bool xf86ResAccessEnter = FALSE;
-
-#ifdef REDUCER
-/* Resources that temporarily conflict with estimated resources */
-static resPtr AccReducers = NULL;
-#endif
-
-/* resource lists */
-resPtr Acc = NULL;
-resPtr osRes = NULL;
-
-/* allocatable ranges */
-resPtr ResRange = NULL;
-
-/* predefined special resources */
-resRange resVgaExclusive[] = {_VGA_EXCLUSIVE, _END};
-resRange resVgaShared[] = {_VGA_SHARED, _END};
-resRange resVgaMemShared[] = {_VGA_SHARED_MEM,_END};
-resRange resVgaIoShared[] = {_VGA_SHARED_IO,_END};
-resRange resVgaUnusedExclusive[] = {_VGA_EXCLUSIVE_UNUSED, _END};
-resRange resVgaUnusedShared[] = {_VGA_SHARED_UNUSED, _END};
-resRange resVgaSparseExclusive[] = {_VGA_EXCLUSIVE_SPARSE, _END};
-resRange resVgaSparseShared[] = {_VGA_SHARED_SPARSE, _END};
-resRange res8514Exclusive[] = {_8514_EXCLUSIVE, _END};
-resRange res8514Shared[] = {_8514_SHARED, _END};
-
-/* Flag: do we need RAC ? */
-static Bool needRAC = FALSE;
-static Bool doFramebufferMode = FALSE;
-
-/* state change notification callback list */
-static StateChangeNotificationPtr StateChangeNotificationList;
-static void notifyStateChange(xf86NotifyState state);
-
-#undef MIN
-#define MIN(x,y) ((x<y)?x:y)
-
-
-/*
- * Call the bus probes relevant to the architecture.
- *
- * The only one available so far is for PCI and SBUS.
- */
-
-void
-xf86BusProbe(void)
-{
- xf86PciProbe();
-#if defined(__sparc__) && !defined(__OpenBSD__)
- xf86SbusProbe();
-#endif
-}
-
-/*
- * Determine what bus type the busID string represents. The start of the
- * bus-dependent part of the string is returned as retID.
- */
-
-BusType
-StringToBusType(const char* busID, const char **retID)
-{
- char *p, *s;
- BusType ret = BUS_NONE;
-
- /* If no type field, Default to PCI */
- if (isdigit(busID[0])) {
- if (retID)
- *retID = busID;
- return BUS_PCI;
- }
-
- s = xstrdup(busID);
- p = strtok(s, ":");
- if (p == NULL || *p == 0) {
- xfree(s);
- return BUS_NONE;
- }
- if (!xf86NameCmp(p, "pci") || !xf86NameCmp(p, "agp"))
- ret = BUS_PCI;
- if (!xf86NameCmp(p, "isa"))
- ret = BUS_ISA;
- if (!xf86NameCmp(p, "sbus"))
- ret = BUS_SBUS;
- if (ret != BUS_NONE)
- if (retID)
- *retID = busID + strlen(p) + 1;
- xfree(s);
- return ret;
-}
-
-/*
- * Entity related code.
- */
-
-void
-xf86EntityInit(void)
-{
- int i;
- resPtr *pprev_next;
- resPtr res;
- xf86AccessPtr pacc;
-
- for (i = 0; i < xf86NumEntities; i++)
- if (xf86Entities[i]->entityInit) {
- if (xf86Entities[i]->access->busAcc)
- ((BusAccPtr)xf86Entities[i]->access->busAcc)->set_f
- (xf86Entities[i]->access->busAcc);
- pacc = xf86Entities[i]->access->fallback;
- if (pacc->AccessEnable)
- pacc->AccessEnable(pacc->arg);
- xf86Entities[i]->entityInit(i,xf86Entities[i]->private);
- if (pacc->AccessDisable)
- pacc->AccessDisable(pacc->arg);
- /* remove init resources after init is processed */
- pprev_next = &Acc;
- res = Acc;
- while (res) {
- if (res->res_type & ResInit && (res->entityIndex == i)) {
- (*pprev_next) = res->next;
- xfree(res);
- } else
- pprev_next = &(res->next);
- res = (*pprev_next);
- }
- }
-}
-
-int
-xf86AllocateEntity(void)
-{
- xf86NumEntities++;
- xf86Entities = xnfrealloc(xf86Entities,
- sizeof(EntityPtr) * xf86NumEntities);
- xf86Entities[xf86NumEntities - 1] = xnfcalloc(1,sizeof(EntityRec));
- xf86Entities[xf86NumEntities - 1]->entityPrivates =
- xnfcalloc(sizeof(DevUnion) * xf86EntityPrivateCount, 1);
- return (xf86NumEntities - 1);
-}
-
-static void
-EntityEnter(void)
-{
- int i;
- xf86AccessPtr pacc;
-
- for (i = 0; i < xf86NumEntities; i++)
- if (xf86Entities[i]->entityEnter) {
- if (xf86Entities[i]->access->busAcc)
- ((BusAccPtr)xf86Entities[i]->access->busAcc)->set_f
- (xf86Entities[i]->access->busAcc);
- pacc = xf86Entities[i]->access->fallback;
- if (pacc->AccessEnable)
- pacc->AccessEnable(pacc->arg);
- xf86Entities[i]->entityEnter(i,xf86Entities[i]->private);
- if (pacc->AccessDisable)
- pacc->AccessDisable(pacc->arg);
- }
-}
-
-static void
-EntityLeave(void)
-{
- int i;
- xf86AccessPtr pacc;
-
- for (i = 0; i < xf86NumEntities; i++)
- if (xf86Entities[i]->entityLeave) {
- if (xf86Entities[i]->access->busAcc)
- ((BusAccPtr)xf86Entities[i]->access->busAcc)->set_f
- (xf86Entities[i]->access->busAcc);
- pacc = xf86Entities[i]->access->fallback;
- if (pacc->AccessEnable)
- pacc->AccessEnable(pacc->arg);
- xf86Entities[i]->entityLeave(i,xf86Entities[i]->private);
- if (pacc->AccessDisable)
- pacc->AccessDisable(pacc->arg);
- }
-}
-
-Bool
-xf86IsEntityPrimary(int entityIndex)
-{
- EntityPtr pEnt = xf86Entities[entityIndex];
-
- if (primaryBus.type != pEnt->busType) return FALSE;
-
- switch (pEnt->busType) {
- case BUS_PCI:
- return (pEnt->pciBusId.bus == primaryBus.id.pci.bus &&
- pEnt->pciBusId.device == primaryBus.id.pci.device &&
- pEnt->pciBusId.func == primaryBus.id.pci.func);
- case BUS_ISA:
- return TRUE;
- case BUS_SBUS:
- return (pEnt->sbusBusId.fbNum == primaryBus.id.sbus.fbNum);
- default:
- return FALSE;
- }
-}
-
-Bool
-xf86SetEntityFuncs(int entityIndex, EntityProc init, EntityProc enter,
- EntityProc leave, pointer private)
-{
- if (entityIndex >= xf86NumEntities)
- return FALSE;
- xf86Entities[entityIndex]->entityInit = init;
- xf86Entities[entityIndex]->entityEnter = enter;
- xf86Entities[entityIndex]->entityLeave = leave;
- xf86Entities[entityIndex]->private = private;
- return TRUE;
-}
-
-Bool
-xf86DriverHasEntities(DriverPtr drvp)
-{
- int i;
- for (i = 0; i < xf86NumEntities; i++) {
- if (xf86Entities[i]->driver == drvp)
- return TRUE;
- }
- return FALSE;
-}
-
-void
-xf86AddEntityToScreen(ScrnInfoPtr pScrn, int entityIndex)
-{
- if (entityIndex == -1)
- return;
- if (xf86Entities[entityIndex]->inUse &&
- !(xf86Entities[entityIndex]->entityProp & IS_SHARED_ACCEL))
- FatalError("Requested Entity already in use!\n");
-
- pScrn->numEntities++;
- pScrn->entityList = xnfrealloc(pScrn->entityList,
- pScrn->numEntities * sizeof(int));
- pScrn->entityList[pScrn->numEntities - 1] = entityIndex;
- xf86Entities[entityIndex]->access->next = pScrn->access;
- pScrn->access = xf86Entities[entityIndex]->access;
- xf86Entities[entityIndex]->inUse = TRUE;
- pScrn->entityInstanceList = xnfrealloc(pScrn->entityInstanceList,
- pScrn->numEntities * sizeof(int));
- pScrn->entityInstanceList[pScrn->numEntities - 1] = 0;
- pScrn->domainIOBase = xf86Entities[entityIndex]->domainIO;
-}
-
-void
-xf86SetEntityInstanceForScreen(ScrnInfoPtr pScrn, int entityIndex, int instance)
-{
- int i;
-
- if (entityIndex == -1 || entityIndex >= xf86NumEntities)
- return;
-
- for (i = 0; i < pScrn->numEntities; i++) {
- if (pScrn->entityList[i] == entityIndex) {
- pScrn->entityInstanceList[i] = instance;
- break;
- }
- }
-}
-
-/*
- * XXX This needs to be updated for the case where a single entity may have
- * instances associated with more than one screen.
- */
-ScrnInfoPtr
-xf86FindScreenForEntity(int entityIndex)
-{
- int i,j;
-
- if (entityIndex == -1) return NULL;
-
- if (xf86Screens) {
- for (i = 0; i < xf86NumScreens; i++) {
- for (j = 0; j < xf86Screens[i]->numEntities; j++) {
- if ( xf86Screens[i]->entityList[j] == entityIndex )
- return (xf86Screens[i]);
- }
- }
- }
- return NULL;
-}
-
-void
-xf86RemoveEntityFromScreen(ScrnInfoPtr pScrn, int entityIndex)
-{
- int i;
- EntityAccessPtr *ptr = (EntityAccessPtr *)&pScrn->access;
- EntityAccessPtr peacc;
-
- for (i = 0; i < pScrn->numEntities; i++) {
- if (pScrn->entityList[i] == entityIndex) {
- peacc = xf86Entities[pScrn->entityList[i]]->access;
- (*ptr) = peacc->next;
- /* disable entity: call disable func */
- if (peacc->pAccess && peacc->pAccess->AccessDisable)
- peacc->pAccess->AccessDisable(peacc->pAccess->arg);
- /* also disable fallback - just in case */
- if (peacc->fallback && peacc->fallback->AccessDisable)
- peacc->fallback->AccessDisable(peacc->fallback->arg);
- for (i++; i < pScrn->numEntities; i++)
- pScrn->entityList[i-1] = pScrn->entityList[i];
- pScrn->numEntities--;
- xf86Entities[entityIndex]->inUse = FALSE;
- break;
- }
- ptr = &(xf86Entities[pScrn->entityList[i]]->access->next);
- }
-}
-
-/*
- * xf86ClearEntitiesForScreen() - called when a screen is deleted
- * to mark it's entities unused. Called by xf86DeleteScreen().
- */
-void
-xf86ClearEntityListForScreen(int scrnIndex)
-{
- ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
- EntityAccessPtr peacc;
- int i, entityIndex;
-
- if (pScrn->entityList == NULL || pScrn->numEntities == 0) return;
-
- for (i = 0; i < pScrn->numEntities; i++) {
- entityIndex = pScrn->entityList[i];
- xf86Entities[entityIndex]->inUse = FALSE;
- /* disable resource: call the disable function */
- peacc = xf86Entities[entityIndex]->access;
- if (peacc->pAccess && peacc->pAccess->AccessDisable)
- peacc->pAccess->AccessDisable(peacc->pAccess->arg);
- /* and the fallback function */
- if (peacc->fallback && peacc->fallback->AccessDisable)
- peacc->fallback->AccessDisable(peacc->fallback->arg);
- /* shared resources are only needed when entity is active: remove */
- xf86DeallocateResourcesForEntity(entityIndex, ResShared);
- }
- xfree(pScrn->entityList);
- xfree(pScrn->entityInstanceList);
- if (pScrn->CurrentAccess->pIoAccess == (EntityAccessPtr)pScrn->access)
- pScrn->CurrentAccess->pIoAccess = NULL;
- if (pScrn->CurrentAccess->pMemAccess == (EntityAccessPtr)pScrn->access)
- pScrn->CurrentAccess->pMemAccess = NULL;
- pScrn->entityList = NULL;
- pScrn->entityInstanceList = NULL;
-}
-
-void
-xf86DeallocateResourcesForEntity(int entityIndex, unsigned long type)
-{
- resPtr *pprev_next = &Acc;
- resPtr res = Acc;
-
- while (res) {
- if (res->entityIndex == entityIndex &&
- (type & ResAccMask & res->res_type))
- {
- (*pprev_next) = res->next;
- xfree(res);
- } else
- pprev_next = &(res->next);
- res = (*pprev_next);
- }
-}
-
-/*
- * Add an extra device section (GDevPtr) to an entity.
- */
-
-void
-xf86AddDevToEntity(int entityIndex, GDevPtr dev)
-{
- EntityPtr pEnt;
-
- if (entityIndex >= xf86NumEntities)
- return;
-
- pEnt = xf86Entities[entityIndex];
- pEnt->numInstances++;
- pEnt->devices = xnfrealloc(pEnt->devices,
- pEnt->numInstances * sizeof(GDevPtr));
- pEnt->devices[pEnt->numInstances - 1] = dev;
- dev->claimed = TRUE;
-}
-
-/*
- * xf86GetEntityInfo() -- This function hands information from the
- * EntityRec struct to the drivers. The EntityRec structure itself
- * remains invisible to the driver.
- */
-EntityInfoPtr
-xf86GetEntityInfo(int entityIndex)
-{
- EntityInfoPtr pEnt;
- int i;
-
- if (entityIndex >= xf86NumEntities)
- return NULL;
-
- pEnt = xnfcalloc(1,sizeof(EntityInfoRec));
- pEnt->index = entityIndex;
- pEnt->location = xf86Entities[entityIndex]->bus;
- pEnt->active = xf86Entities[entityIndex]->active;
- pEnt->chipset = xf86Entities[entityIndex]->chipset;
- pEnt->resources = xf86Entities[entityIndex]->resources;
- pEnt->driver = xf86Entities[entityIndex]->driver;
- if ( (xf86Entities[entityIndex]->devices) &&
- (xf86Entities[entityIndex]->devices[0]) ) {
- for (i = 0; i < xf86Entities[entityIndex]->numInstances; i++)
- if (xf86Entities[entityIndex]->devices[i]->screen == 0)
- break;
- pEnt->device = xf86Entities[entityIndex]->devices[i];
- } else
- pEnt->device = NULL;
-
- return pEnt;
-}
-
-int
-xf86GetNumEntityInstances(int entityIndex)
-{
- if (entityIndex >= xf86NumEntities)
- return -1;
-
- return xf86Entities[entityIndex]->numInstances;
-}
-
-GDevPtr
-xf86GetDevFromEntity(int entityIndex, int instance)
-{
- int i;
-
- /* We might not use AddDevtoEntity */
- if ( (!xf86Entities[entityIndex]->devices) ||
- (!xf86Entities[entityIndex]->devices[0]) )
- return NULL;
-
- if (entityIndex >= xf86NumEntities ||
- instance >= xf86Entities[entityIndex]->numInstances)
- return NULL;
-
- for (i = 0; i < xf86Entities[entityIndex]->numInstances; i++)
- if (xf86Entities[entityIndex]->devices[i]->screen == instance)
- break;
- return xf86Entities[entityIndex]->devices[i];
-}
-
-/*
- * general generic disable function.
- */
-static void
-disableAccess(void)
-{
- int i;
- xf86AccessPtr pacc;
- EntityAccessPtr peacc;
-
- /* call disable funcs and reset current access pointer */
- /* the entity specific access funcs are in an enabled */
- /* state - driver must restore their state explicitely */
- for (i = 0; i < xf86NumScreens; i++) {
- peacc = xf86Screens[i]->CurrentAccess->pIoAccess;
- while (peacc) {
- if (peacc->pAccess && peacc->pAccess->AccessDisable)
- peacc->pAccess->AccessDisable(peacc->pAccess->arg);
- peacc = peacc->next;
- }
- xf86Screens[i]->CurrentAccess->pIoAccess = NULL;
- peacc = xf86Screens[i]->CurrentAccess->pMemAccess;
- while (peacc) {
- if (peacc->pAccess && peacc->pAccess->AccessDisable)
- peacc->pAccess->AccessDisable(peacc->pAccess->arg);
- peacc = peacc->next;
- }
- xf86Screens[i]->CurrentAccess->pMemAccess = NULL;
- }
- /* then call the generic entity disable funcs */
- for (i = 0; i < xf86NumEntities; i++) {
- pacc = xf86Entities[i]->access->fallback;
- if (pacc->AccessDisable)
- pacc->AccessDisable(pacc->arg);
- }
-}
-
-static void
-clearAccess(void)
-{
- int i;
-
- /* call disable funcs and reset current access pointer */
- /* the entity specific access funcs are in an enabled */
- /* state - driver must restore their state explicitely */
- for (i = 0; i < xf86NumScreens; i++) {
- xf86Screens[i]->CurrentAccess->pIoAccess = NULL;
- xf86Screens[i]->CurrentAccess->pMemAccess = NULL;
- }
-
-}
-
-/*
- * Generic interface to bus specific code - add other buses here
- */
-
-/*
- * xf86AccessInit() - set up everything needed for access control
- * called only once on first server generation.
- */
-void
-xf86AccessInit(void)
-{
- initPciState();
- initPciBusState();
- DisablePciBusAccess();
- DisablePciAccess();
-
- xf86ResAccessEnter = TRUE;
-}
-
-/*
- * xf86AccessEnter() -- gets called to save the text mode VGA IO
- * resources when reentering the server after a VT switch.
- */
-void
-xf86AccessEnter(void)
-{
- if (xf86ResAccessEnter)
- return;
-
- /*
- * on enter we simply disable routing of special resources
- * to any bus and let the RAC code to "open" the right bridges.
- */
- PciBusStateEnter();
- DisablePciBusAccess();
- PciStateEnter();
- disableAccess();
- EntityEnter();
- notifyStateChange(NOTIFY_ENTER);
- xf86EnterServerState(SETUP);
- xf86ResAccessEnter = TRUE;
-}
-
-/*
- * xf86AccessLeave() -- prepares access for and calls the
- * entityLeave() functions.
- * xf86AccessLeaveState() --- gets called to restore the
- * access to the VGA IO resources when switching VT or on
- * server exit.
- * This was split to call xf86AccessLeaveState() from
- * ddxGiveUp().
- */
-void
-xf86AccessLeave(void)
-{
- if (!xf86ResAccessEnter)
- return;
- notifyStateChange(NOTIFY_LEAVE);
- disableAccess();
- DisablePciBusAccess();
- EntityLeave();
-}
-
-void
-xf86AccessLeaveState(void)
-{
- if (!xf86ResAccessEnter)
- return;
- xf86ResAccessEnter = FALSE;
- PciStateLeave();
- PciBusStateLeave();
-}
-
-/*
- * xf86AccessRestoreState() - Restore the access registers to the
- * state before X was started. This is handy for framebuffers.
- */
-static void
-xf86AccessRestoreState(void)
-{
- if (!xf86ResAccessEnter)
- return;
- PciStateLeave();
- PciBusStateLeave();
-}
-
-/*
- * xf86EnableAccess() -- enable access to controlled resources.
- * To reduce latency when switching access the ScrnInfoRec has
- * a linked list of the EntityAccPtr of all screen entities.
- */
-/*
- * switching access needs to be done in te following oder:
- * disable
- * 1. disable old entity
- * 2. reroute bus
- * 3. enable new entity
- * Otherwise resources needed for access control might be shadowed
- * by other resources!
- */
-#ifdef async
-
-static AsyncQPtr *AsyncQ = NULL;
-ScrnInfoPtr xf86CurrentScreen = NULL;
-
-#define SETUP_Q org = AsyncQ; \
- AsyncQ = &new;
-
-#define PROCESS_Q xf86CurrentScreen = pScrn;
- if (!new) AsyncQ = org; \
- else { \
- AsyncQPtr tmp_Q; \
- while (1) {\
- new->func(new->arg);\
- if (!(new->next)) {\
- AsyncQ = org; xfree(new); break; \
- } \
- tmp_Q = new->next; \
- xfree(new); \
- new = tmp_Q; \
- } \
- }
-#else
-#define SETUP_Q
-#define PROCESS_Q
-#endif
-
-void
-xf86EnableAccess(ScrnInfoPtr pScrn)
-{
- register EntityAccessPtr peAcc = (EntityAccessPtr) pScrn->access;
- register EntityAccessPtr pceAcc;
- register xf86AccessPtr pAcc;
- EntityAccessPtr tmp;
-#ifdef async
- AsyncQPtr *org, new = NULL;
-#endif
-
-#ifdef DEBUG
- ErrorF("Enable access %i\n",pScrn->scrnIndex);
-#endif
-
- /* Entity is not under access control or currently enabled */
- if (!pScrn->access) {
- if (pScrn->busAccess) {
- SETUP_Q;
- ((BusAccPtr)pScrn->busAccess)->set_f(pScrn->busAccess);
- PROCESS_Q;
- }
- return;
- }
-
- switch (pScrn->resourceType) {
- case IO:
- pceAcc = pScrn->CurrentAccess->pIoAccess;
- if (peAcc == pceAcc) {
- return;
- }
- SETUP_Q;
- if (pScrn->CurrentAccess->pMemAccess == pceAcc)
- pScrn->CurrentAccess->pMemAccess = NULL;
- while (pceAcc) {
- pAcc = pceAcc->pAccess;
- if ( pAcc && pAcc->AccessDisable)
- (*pAcc->AccessDisable)(pAcc->arg);
- pceAcc = pceAcc->next;
- }
- if (pScrn->busAccess)
- ((BusAccPtr)pScrn->busAccess)->set_f(pScrn->busAccess);
- while (peAcc) {
- pAcc = peAcc->pAccess;
- if (pAcc && pAcc->AccessEnable)
- (*pAcc->AccessEnable)(pAcc->arg);
- peAcc = peAcc->next;
- }
- pScrn->CurrentAccess->pIoAccess = (EntityAccessPtr) pScrn->access;
- PROCESS_Q;
- return;
-
- case MEM_IO:
- pceAcc = pScrn->CurrentAccess->pIoAccess;
- if (peAcc != pceAcc) { /* current Io != pAccess */
- SETUP_Q;
- tmp = pceAcc;
- while (pceAcc) {
- pAcc = pceAcc->pAccess;
- if (pAcc && pAcc->AccessDisable)
- (*pAcc->AccessDisable)(pAcc->arg);
- pceAcc = pceAcc->next;
- }
- pceAcc = pScrn->CurrentAccess->pMemAccess;
- if (peAcc != pceAcc /* current Mem != pAccess */
- && tmp !=pceAcc) {
- while (pceAcc) {
- pAcc = pceAcc->pAccess;
- if (pAcc && pAcc->AccessDisable)
- (*pAcc->AccessDisable)(pAcc->arg);
- pceAcc = pceAcc->next;
- }
- }
- } else { /* current Io == pAccess */
- pceAcc = pScrn->CurrentAccess->pMemAccess;
- if (pceAcc == peAcc) { /* current Mem == pAccess */
- return;
- }
- SETUP_Q;
- while (pceAcc) { /* current Mem != pAccess */
- pAcc = pceAcc->pAccess;
- if (pAcc && pAcc->AccessDisable)
- (*pAcc->AccessDisable)(pAcc->arg);
- pceAcc = pceAcc->next;
- }
- }
- if (pScrn->busAccess)
- ((BusAccPtr)pScrn->busAccess)->set_f(pScrn->busAccess);
- while (peAcc) {
- pAcc = peAcc->pAccess;
- if (pAcc && pAcc->AccessEnable)
- (*pAcc->AccessEnable)(pAcc->arg);
- peAcc = peAcc->next;
- }
- pScrn->CurrentAccess->pMemAccess =
- pScrn->CurrentAccess->pIoAccess = (EntityAccessPtr) pScrn->access;
- PROCESS_Q;
- return;
-
- case MEM:
- pceAcc = pScrn->CurrentAccess->pMemAccess;
- if (peAcc == pceAcc) {
- return;
- }
- SETUP_Q;
- if (pScrn->CurrentAccess->pIoAccess == pceAcc)
- pScrn->CurrentAccess->pIoAccess = NULL;
- while (pceAcc) {
- pAcc = pceAcc->pAccess;
- if ( pAcc && pAcc->AccessDisable)
- (*pAcc->AccessDisable)(pAcc->arg);
- pceAcc = pceAcc->next;
- }
- if (pScrn->busAccess)
- ((BusAccPtr)pScrn->busAccess)->set_f(pScrn->busAccess);
- while (peAcc) {
- pAcc = peAcc->pAccess;
- if (pAcc && pAcc->AccessEnable)
- (*pAcc->AccessEnable)(pAcc->arg);
- peAcc = peAcc->next;
- }
- pScrn->CurrentAccess->pMemAccess = (EntityAccessPtr) pScrn->access;
- PROCESS_Q;
- return;
-
- case NONE:
- if (pScrn->busAccess) {
- SETUP_Q;
- ((BusAccPtr)pScrn->busAccess)->set_f(pScrn->busAccess);
- PROCESS_Q;
- }
- return;
- }
-}
-
-void
-xf86SetCurrentAccess(Bool Enable, ScrnInfoPtr pScrn)
-{
- EntityAccessPtr pceAcc2 = NULL;
- register EntityAccessPtr pceAcc = NULL;
- register xf86AccessPtr pAcc;
-
-
- switch(pScrn->resourceType) {
- case IO:
- pceAcc = pScrn->CurrentAccess->pIoAccess;
- break;
- case MEM:
- pceAcc = pScrn->CurrentAccess->pMemAccess;
- break;
- case MEM_IO:
- pceAcc = pScrn->CurrentAccess->pMemAccess;
- pceAcc2 = pScrn->CurrentAccess->pIoAccess;
- break;
- default:
- break;
- }
-
- while (pceAcc) {
- pAcc = pceAcc->pAccess;
- if ( pAcc) {
- if (!Enable) {
- if (pAcc->AccessDisable)
- (*pAcc->AccessDisable)(pAcc->arg);
- } else {
- if (pAcc->AccessEnable)
- (*pAcc->AccessEnable)(pAcc->arg);
- }
- }
- pceAcc = pceAcc->next;
- if (!pceAcc) {
- pceAcc = pceAcc2;
- pceAcc2 = NULL;
- }
- }
-}
-
-void
-xf86SetAccessFuncs(EntityInfoPtr pEnt, xf86SetAccessFuncPtr funcs,
- xf86SetAccessFuncPtr oldFuncs)
-{
- AccessFuncPtr rac;
-
- if (!xf86Entities[pEnt->index]->rac)
- xf86Entities[pEnt->index]->rac = xnfcalloc(1,sizeof(AccessFuncRec));
-
- rac = xf86Entities[pEnt->index]->rac;
-
- if (funcs->mem == funcs->io_mem && funcs->mem && funcs->io)
- xf86Entities[pEnt->index]->entityProp |= NO_SEPARATE_MEM_FROM_IO;
- if (funcs->io == funcs->io_mem && funcs->mem && funcs->io)
- xf86Entities[pEnt->index]->entityProp |= NO_SEPARATE_IO_FROM_MEM;
-
- rac->mem_new = funcs->mem;
- rac->io_new = funcs->io;
- rac->io_mem_new = funcs->io_mem;
-
- rac->old = oldFuncs;
-}
-
-/*
- * Conflict checking
- */
-
-static memType
-getMask(memType val)
-{
- memType mask = 0;
- memType tmp = 0;
-
- mask=~mask;
- tmp = ~((~tmp) >> 1);
-
- while (!(val & tmp)) {
- mask = mask >> 1;
- val = val << 1;
- }
- return mask;
-}
-
-/*
- * checkConflictBlock() -- check for conflicts of a block resource range.
- * If conflict is found return end of conflicting range. Else return 0.
- */
-static memType
-checkConflictBlock(resRange *range, resPtr pRes)
-{
- memType val,tmp,prev;
- int i;
-
- switch (pRes->res_type & ResExtMask) {
- case ResBlock:
- if (range->rBegin < pRes->block_end &&
- range->rEnd > pRes->block_begin) {
-#ifdef DEBUG
- ErrorF("b-b conflict w: %lx %lx\n",
- pRes->block_begin,pRes->block_end);
-#endif
- return pRes->block_end < range->rEnd ?
- pRes->block_end : range->rEnd;
- }
- return 0;
- case ResSparse:
- if (pRes->sparse_base > range->rEnd) return 0;
-
- val = (~pRes->sparse_mask | pRes->sparse_base) & getMask(range->rEnd);
-#ifdef DEBUG
- ErrorF("base = 0x%lx, mask = 0x%lx, begin = 0x%lx, end = 0x%lx ,"
- "val = 0x%lx\n",
- pRes->sparse_base, pRes->sparse_mask, range->rBegin,
- range->rEnd, val);
-#endif
- i = sizeof(memType) * 8;
- tmp = prev = pRes->sparse_base;
-
- while (i) {
- tmp |= 1<< (--i) & val;
- if (tmp > range->rEnd)
- tmp = prev;
- else
- prev = tmp;
- }
- if (tmp >= range->rBegin) {
-#ifdef DEBUG
- ErrorF("conflict found at: 0x%lx\n",tmp);
- ErrorF("b-d conflict w: %lx %lx\n",
- pRes->sparse_base,pRes->sparse_mask);
-#endif
- return tmp;
- }
- else
- return 0;
- }
- return 0;
-}
-
-/*
- * checkConflictSparse() -- check for conflicts of a sparse resource range.
- * If conflict is found return base of conflicting region. Else return 0.
- */
-#define mt_max ~(memType)0
-#define length sizeof(memType) * 8
-static memType
-checkConflictSparse(resRange *range, resPtr pRes)
-{
- memType val, tmp, prev;
- int i;
-
- switch (pRes->res_type & ResExtMask) {
- case ResSparse:
- tmp = pRes->sparse_mask & range->rMask;
- if ((tmp & pRes->sparse_base) == (tmp & range->rBase)) {
-#ifdef DEBUG
- ErrorF("s-b conflict w: %lx %lx\n",
- pRes->sparse_base,pRes->sparse_mask);
-#endif
- return pRes->sparse_mask;
- }
- return 0;
-
- case ResBlock:
- if (pRes->block_end < range->rBase) return 0;
-
- val = (~range->rMask | range->rBase) & getMask(pRes->block_end);
- i = length;
- tmp = prev = range->rBase;
-
- while (i) {
-#ifdef DEBUG
- ErrorF("tmp = 0x%lx\n",tmp);
-#endif
- tmp |= 1<< (--i) & val;
- if (tmp > pRes->block_end)
- tmp = prev;
- else
- prev = tmp;
- }
- if (tmp < pRes->block_begin)
- return 0;
- else {
- /*
- * now we subdivide the block region in sparse regions
- * with base values = 2^n and find the smallest mask.
- * This might be done in a simpler way....
- */
- memType mask, m_mask = 0, base = pRes->block_begin;
- int i;
- while (base < pRes->block_end) {
- for (i = 1; i < length; i++)
- if ( base != (base & (mt_max << i))) break;
- mask = mt_max >> (length - i);
- do mask >>= 1;
- while ((mask + base + 1) > pRes->block_end);
- /* m_mask and are _inverted_ sparse masks */
- m_mask = mask > m_mask ? mask : m_mask;
- base = base + mask + 1;
- }
-#ifdef DEBUG
- ErrorF("conflict found at: 0x%lx\n",tmp);
- ErrorF("b-b conflict w: %lx %lx\n",
- pRes->block_begin,pRes->block_end);
-#endif
- return ~m_mask;
- }
- }
- return 0;
-}
-#undef mt_max
-#undef length
-
-/*
- * needCheck() -- this function decides whether to check for conflicts
- * depending on the types of the resource ranges and their locations
- */
-static Bool
-needCheck(resPtr pRes, unsigned long type, int entityIndex, xf86State state)
-{
- /* the same entity shouldn't conflict with itself */
- ScrnInfoPtr pScrn;
- int i;
- BusType loc = BUS_NONE;
- BusType r_loc = BUS_NONE;
-
- /* Ignore overlapped ranges that have been nullified */
- if ((pRes->res_type & ResOverlap) && (pRes->block_begin > pRes->block_end))
- return FALSE;
-
- if ((pRes->res_type & ResTypeMask) != (type & ResTypeMask))
- return FALSE;
-
- /*
- * Resources set by BIOS (ResBios) are allowed to conflict
- * with resources marked (ResBios).
- */
- if (pRes->res_type & type & ResBios)
- return FALSE;
-
- /*If requested, skip over estimated resources */
- if (pRes->res_type & type & ResEstimated)
- return FALSE;
-
- if (type & pRes->res_type & ResUnused)
- return FALSE;
-
- if (state == OPERATING) {
- if (type & ResDisableOpr || pRes->res_type & ResDisableOpr)
- return FALSE;
- if (type & pRes->res_type & ResUnusedOpr) return FALSE;
- /*
- * Maybe we should have ResUnused set The resUnusedOpr
- * bit, too. This way we could avoid this confusion
- */
- if ((type & ResUnusedOpr && pRes->res_type & ResUnused) ||
- (type & ResUnused && pRes->res_type & ResUnusedOpr))
- return FALSE;
- }
-
- if (entityIndex > -1)
- loc = xf86Entities[entityIndex]->busType;
- if (pRes->entityIndex > -1)
- r_loc = xf86Entities[pRes->entityIndex]->busType;
-
- switch (type & ResAccMask) {
- case ResExclusive:
- switch (pRes->res_type & ResAccMask) {
- case ResExclusive:
- break;
- case ResShared:
- /* ISA buses are only locally exclusive on a PCI system */
- if (loc == BUS_ISA && r_loc == BUS_PCI)
- return FALSE;
- break;
- }
- break;
- case ResShared:
- switch (pRes->res_type & ResAccMask) {
- case ResExclusive:
- /* ISA buses are only locally exclusive on a PCI system */
- if (loc == BUS_PCI && r_loc == BUS_ISA)
- return FALSE;
- break;
- case ResShared:
- return FALSE;
- }
- break;
- case ResAny:
- break;
- }
-
- if (pRes->entityIndex == entityIndex) return FALSE;
-
- if (pRes->entityIndex > -1 &&
- (pScrn = xf86FindScreenForEntity(entityIndex))) {
- for (i = 0; i < pScrn->numEntities; i++)
- if (pScrn->entityList[i] == pRes->entityIndex) return FALSE;
- }
- return TRUE;
-}
-
-/*
- * checkConflict() - main conflict checking function which all other
- * function call.
- */
-static memType
-checkConflict(resRange *rgp, resPtr pRes, int entityIndex,
- xf86State state, Bool ignoreIdentical)
-{
- memType ret;
-
- while(pRes) {
- if (!needCheck(pRes,rgp->type, entityIndex ,state)) {
- pRes = pRes->next;
- continue;
- }
- switch (rgp->type & ResExtMask) {
- case ResBlock:
- if (rgp->rEnd < rgp->rBegin) {
- xf86Msg(X_ERROR,"end of block range 0x%lx < begin 0x%lx\n",
- rgp->rEnd,rgp->rBegin);
- return 0;
- }
- if ((ret = checkConflictBlock(rgp, pRes))) {
- if (!ignoreIdentical || (rgp->rBegin != pRes->block_begin)
- || (rgp->rEnd != pRes->block_end))
- return ret;
- }
- break;
- case ResSparse:
- if ((rgp->rBase & rgp->rMask) != rgp->rBase) {
- xf86Msg(X_ERROR,"sparse io range (base: 0x%lx mask: 0x%lx)"
- "doesn't satisfy (base & mask = mask)\n",
- rgp->rBase, rgp->rMask);
- return 0;
- }
- if ((ret = checkConflictSparse(rgp, pRes))) {
- if (!ignoreIdentical || (rgp->rBase != pRes->sparse_base)
- || (rgp->rMask != pRes->sparse_mask))
- return ret;
- }
- break;
- }
- pRes = pRes->next;
- }
- return 0;
-}
-
-/*
- * ChkConflict() -- used within xxxBus ; find conflict with any location.
- */
-memType
-ChkConflict(resRange *rgp, resPtr res, xf86State state)
-{
- return checkConflict(rgp, res, -2, state,FALSE);
-}
-
-/*
- * xf86ChkConflict() - This function is the low level interface to
- * the resource broker that gets exported. Tests all resources ie.
- * performs test with SETUP flag.
- */
-memType
-xf86ChkConflict(resRange *rgp, int entityIndex)
-{
- return checkConflict(rgp, Acc, entityIndex, SETUP,FALSE);
-}
-
-/*
- * Resources List handling
- */
-
-resPtr
-xf86JoinResLists(resPtr rlist1, resPtr rlist2)
-{
- resPtr pRes;
-
- if (!rlist1)
- return rlist2;
-
- if (!rlist2)
- return rlist1;
-
- for (pRes = rlist1; pRes->next; pRes = pRes->next)
- ;
- pRes->next = rlist2;
- return rlist1;
-}
-
-resPtr
-xf86AddResToList(resPtr rlist, resRange *range, int entityIndex)
-{
- resPtr new;
-
- switch (range->type & ResExtMask) {
- case ResBlock:
- if (range->rEnd < range->rBegin) {
- xf86Msg(X_ERROR,"end of block range 0x%lx < begin 0x%lx\n",
- range->rEnd,range->rBegin);
- return rlist;
- }
- break;
- case ResSparse:
- if ((range->rBase & range->rMask) != range->rBase) {
- xf86Msg(X_ERROR,"sparse io range (base: 0x%lx mask: 0x%lx)"
- "doesn't satisfy (base & mask = mask)\n",
- range->rBase, range->rMask);
- return rlist;
- }
- break;
- }
-
- new = xnfalloc(sizeof(resRec));
- /*
- * Only background resources may be registered with ResBios
- * and ResEstimated set. Other resources only set it for
- * testing.
- */
- if (entityIndex != (-1))
- range->type &= ~(ResBios | ResEstimated);
- new->val = *range;
- new->entityIndex = entityIndex;
- new->next = rlist;
- return new;
-}
-
-void
-xf86FreeResList(resPtr rlist)
-{
- resPtr pRes;
-
- if (!rlist)
- return;
-
- for (pRes = rlist->next; pRes; rlist = pRes, pRes = pRes->next)
- xfree(rlist);
- xfree(rlist);
-}
-
-resPtr
-xf86DupResList(const resPtr rlist)
-{
- resPtr pRes, ret, prev, new;
-
- if (!rlist)
- return NULL;
-
- ret = xnfalloc(sizeof(resRec));
- *ret = *rlist;
- prev = ret;
- for (pRes = rlist->next; pRes; pRes = pRes->next) {
- new = xnfalloc(sizeof(resRec));
- *new = *pRes;
- prev->next = new;
- prev = new;
- }
- return ret;
-}
-
-void
-xf86PrintResList(int verb, resPtr list)
-{
- int i = 0;
- const char *s, *r;
- resPtr tmp = list;
- unsigned long type;
-
- if (!list)
- return;
-
- type = ResMem;
- r = "M";
- while (1) {
- while (list) {
- if ((list->res_type & ResPhysMask) == type) {
- switch (list->res_type & ResExtMask) {
- case ResBlock:
- xf86ErrorFVerb(verb,
- "\t[%d] %d\t%ld\t0x%08lx - 0x%08lx (0x%lx)",
- i, list->entityIndex,
- (list->res_type & ResDomain) >> 24,
- list->block_begin, list->block_end,
- list->block_end - list->block_begin + 1);
- break;
- case ResSparse:
- xf86ErrorFVerb(verb, "\t[%d] %d\t%ld\t0x%08lx - 0x%08lx ",
- i, list->entityIndex,
- (list->res_type & ResDomain) >> 24,
- list->sparse_base,list->sparse_mask);
- break;
- default:
- list = list->next;
- continue;
- }
- xf86ErrorFVerb(verb, " %s", r);
- switch (list->res_type & ResAccMask) {
- case ResExclusive:
- if (list->res_type & ResUnused)
- s = "x";
- else
- s = "X";
- break;
- case ResShared:
- if (list->res_type & ResUnused)
- s = "s";
- else
- s = "S";
- break;
- default:
- s = "?";
- }
- xf86ErrorFVerb(verb, "%s", s);
- switch (list->res_type & ResExtMask) {
- case ResBlock:
- s = "[B]";
- break;
- case ResSparse:
- s = "[S]";
- break;
- default:
- s = "[?]";
- }
- xf86ErrorFVerb(verb, "%s", s);
- if (list->res_type & ResEstimated)
- xf86ErrorFVerb(verb, "E");
- if (list->res_type & ResOverlap)
- xf86ErrorFVerb(verb, "O");
- if (list->res_type & ResInit)
- xf86ErrorFVerb(verb, "t");
- if (list->res_type & ResBios)
- xf86ErrorFVerb(verb, "(B)");
- if (list->res_type & ResBus)
- xf86ErrorFVerb(verb, "(b)");
- if (list->res_type & ResOprMask) {
- switch (list->res_type & ResOprMask) {
- case ResUnusedOpr:
- s = "(OprU)";
- break;
- case ResDisableOpr:
- s = "(OprD)";
- break;
- default:
- s = "(Opr?)";
- break;
- }
- xf86ErrorFVerb(verb, "%s", s);
- }
- xf86ErrorFVerb(verb, "\n");
- i++;
- }
- list = list->next;
- }
- if (type == ResIo) break;
- type = ResIo;
- r = "I";
- list = tmp;
- }
-}
-
-resPtr
-xf86AddRangesToList(resPtr list, resRange *pRange, int entityIndex)
-{
- while(pRange && pRange->type != ResEnd) {
- list = xf86AddResToList(list,pRange,entityIndex);
- pRange++;
- }
- return list;
-}
-
-void
-xf86ResourceBrokerInit(void)
-{
- resPtr resPci;
-
- osRes = NULL;
-
- /* Get the addressable ranges */
- ResRange = xf86BusAccWindowsFromOS();
- xf86MsgVerb(X_INFO, 3, "Addressable bus resource ranges are\n");
- xf86PrintResList(3, ResRange);
-
- /* Get the ranges used exclusively by the system */
- osRes = xf86AccResFromOS(osRes);
- xf86MsgVerb(X_INFO, 3, "OS-reported resource ranges:\n");
- xf86PrintResList(3, osRes);
-
- /* Bus dep initialization */
- resPci = ResourceBrokerInitPci(&osRes);
- Acc = xf86JoinResLists(xf86DupResList(osRes), resPci);
-
- xf86MsgVerb(X_INFO, 3, "All system resource ranges:\n");
- xf86PrintResList(3, Acc);
-
-}
-
-#define MEM_ALIGN (1024 * 1024)
-
-/*
- * RemoveOverlaps() -- remove overlaps between resources of the
- * same kind.
- * Beware: This function doesn't check for access attributes.
- * At resource broker initialization this is no problem as this
- * only deals with exclusive resources.
- */
-#if 0
-void
-RemoveOverlaps(resPtr target, resPtr list, Bool pow2Alignment, Bool useEstimated)
-{
- resPtr pRes;
- memType size, newsize, adjust;
-
- if (!target)
- return;
-
- for (pRes = list; pRes; pRes = pRes->next) {
- if (pRes != target
- && ((pRes->res_type & ResTypeMask) ==
- (target->res_type & ResTypeMask))
- && pRes->block_begin <= target->block_end
- && pRes->block_end >= target->block_begin) {
- /* Possibly ignore estimated resources */
- if (!useEstimated && (pRes->res_type & ResEstimated)) continue;
- /*
- * Target should be a larger region than pRes. If pRes fully
- * contains target, don't do anything unless target can overlap.
- */
- if (pRes->block_begin <= target->block_begin &&
- pRes->block_end >= target->block_end) {
- if (target->res_type & ResOverlap) {
- /* Nullify range but keep its ResOverlap bit on */
- target->block_end = target->block_begin - 1;
- return;
- }
- continue;
- }
- /*
- * In cases where the target and pRes have the same starting
- * address, reduce the size of the target (given it's an estimate).
- */
- if (pRes->block_begin == target->block_begin) {
- if (target->res_type & ResOverlap)
- target->block_end = target->block_begin - 1;
- else
- target->block_end = pRes->block_end;
- }
- /* Otherwise, trim target to remove the overlap */
- else if (pRes->block_begin <= target->block_end) {
- target->block_end = pRes->block_begin - 1;
- } else if (!pow2Alignment &&
- pRes->block_end >= target->block_begin) {
- target->block_begin = pRes->block_end + 1;
- }
- if (pow2Alignment) {
- /*
- * Align to a power of two. This requires finding the
- * largest power of two that is smaller than the adjusted
- * size.
- */
- size = target->block_end - target->block_begin + 1;
- newsize = 1UL << (sizeof(memType) * 8 - 1);
- while (!(newsize & size))
- newsize >>= 1;
- target->block_end = target->block_begin + newsize - 1;
- } else if (target->block_end > MEM_ALIGN) {
- /* Align the end to MEM_ALIGN */
- if ((adjust = (target->block_end + 1) % MEM_ALIGN))
- target->block_end -= adjust;
- }
- }
- }
-}
-#else
-
-void
-RemoveOverlaps(resPtr target, resPtr list, Bool pow2Alignment, Bool useEstimated)
-{
- resPtr pRes;
- memType size, newsize, adjust;
-
- if (!target)
- return;
-
- if (!(target->res_type & ResEstimated) /* Don't touch sure resources */
- && !(target->res_type & ResOverlap)) /* Unless they may overlap */
- return;
-
- for (pRes = list; pRes; pRes = pRes->next) {
- if (pRes == target
- || ((pRes->res_type & ResTypeMask) !=
- (target->res_type & ResTypeMask))
- || pRes->block_begin > target->block_end
- || pRes->block_end < target->block_begin)
- continue;
-
- if (pRes->block_begin <= target->block_begin) {
- /* Possibly ignore estimated resources */
- if (!useEstimated && (pRes->res_type & ResEstimated))
- continue;
-
- /* Special cases */
- if (pRes->block_end >= target->block_end) {
- /*
- * If pRes fully contains target, don't do anything
- * unless target can overlap.
- */
- if (target->res_type & ResOverlap) {
- /* Nullify range but keep its ResOverlap bit on */
- target->block_end = target->block_begin - 1;
- return;
- } else
- continue;
- } else {
-#if 0 /* Don't trim start address - we trust what we got */
- /*
- * If !pow2Alignment trim start address: !pow2Alingment
- * is only set when estimated OS addresses are handled.
- * In cases where the target and pRes have the same
- * starting address, reduce the size of the target
- * (given it's an estimate).
- */
- if (!pow2Alignment)
- target->block_begin = pRes->block_end + 1;
- else
-#endif
- if (pRes->block_begin == target->block_begin)
- target->block_end = pRes->block_end;
- else
- continue;
- }
- } else {
- /* Trim target to remove the overlap */
- target->block_end = pRes->block_begin - 1;
- }
- if (pow2Alignment) {
- /*
- * Align to a power of two. This requires finding the
- * largest power of two that is smaller than the adjusted
- * size.
- */
- size = target->block_end - target->block_begin + 1;
- newsize = 1UL << (sizeof(memType) * 8 - 1);
- while (!(newsize & size))
- newsize >>= 1;
- target->block_end = target->block_begin + newsize - 1;
- } else if (target->block_end > MEM_ALIGN) {
- /* Align the end to MEM_ALIGN */
- if ((adjust = (target->block_end + 1) % MEM_ALIGN))
- target->block_end -= adjust;
- }
- }
-}
-
-#endif
-
-/*
- * Resource request code
- */
-
-#define ALIGN(x,a) ((x) + a) &~(a)
-
-resRange
-xf86GetBlock(unsigned long type, memType size,
- memType window_start, memType window_end,
- memType align_mask, resPtr avoid)
-{
- memType min, max, tmp;
- resRange r = {ResEnd,0,0};
- resPtr res_range = ResRange;
-
- if (!size) return r;
- if (window_end < window_start || (window_end - window_start) < (size - 1)) {
- ErrorF("Requesting insufficient memory window!:"
- " start: 0x%lx end: 0x%lx size 0x%lx\n",
- window_start,window_end,size);
- return r;
- }
- type = (type & ~(ResExtMask | ResBios | ResEstimated)) | ResBlock;
-
- while (res_range) {
- if ((type & ResTypeMask) == (res_range->res_type & ResTypeMask)) {
- if (res_range->block_begin > window_start)
- min = res_range->block_begin;
- else
- min = window_start;
- if (res_range->block_end < window_end)
- max = res_range->block_end;
- else
- max = window_end;
- min = ALIGN(min,align_mask);
- /* do not produce an overflow! */
- while (min < max && (max - min) >= (size - 1)) {
- RANGE(r,min,min + size - 1,type);
- tmp = ChkConflict(&r,Acc,SETUP);
- if (!tmp) {
- tmp = ChkConflict(&r,avoid,SETUP);
- if (!tmp) {
- return r;
- }
- }
- min = ALIGN(tmp,align_mask);
- }
- }
- res_range = res_range->next;
- }
- RANGE(r,0,0,ResEnd);
- return r;
-}
-
-#define mt_max ~(memType)0
-#define length sizeof(memType) * 8
-/*
- * make_base() -- assign the lowest bits to the bits set in mask.
- * example: mask 011010 val 0000110 -> 011000
- */
-static memType
-make_base(memType val, memType mask)
-{
- int i,j = 0;
- memType ret = 0
- ;
- for (i = 0;i<length;i++) {
- if ((1 << i) & mask) {
- ret |= (((val >> j) & 1) << i);
- j++;
- }
- }
- return ret;
-}
-
-/*
- * make_base() -- assign the bits set in mask to the lowest bits.
- * example: mask 011010 , val 010010 -> 000011
- */
-static memType
-unmake_base(memType val, memType mask)
-{
- int i,j = 0;
- memType ret = 0;
-
- for (i = 0;i<length;i++) {
- if ((1 << i) & mask) {
- ret |= (((val >> i) & 1) << j);
- j++;
- }
- }
- return ret;
-}
-
-static memType
-fix_counter(memType val, memType old_mask, memType mask)
-{
- mask = old_mask & mask;
-
- val = make_base(val,old_mask);
- return unmake_base(val,mask);
-}
-
-resRange
-xf86GetSparse(unsigned long type, memType fixed_bits,
- memType decode_mask, memType address_mask, resPtr avoid)
-{
- resRange r = {ResEnd,0,0};
- memType new_mask;
- memType mask1;
- memType base;
- memType counter = 0;
- memType counter1;
- memType max_counter = ~(memType)0;
- memType max_counter1;
- memType conflict = 0;
-
- /* for sanity */
- type = (type & ~(ResExtMask | ResBios | ResEstimated)) | ResSparse;
-
- /*
- * a sparse address consists of 3 parts:
- * fixed_bits: F bits which hard decoded by the hardware
- * decode_bits: D bits which are used to decode address
- * but which may be set by software
- * address_bits: A bits which are used to address the
- * sparse range.
- * the decode_mask marks all decode bits while the address_mask
- * masks out all address_bits:
- * F D A
- * decode_mask: 0 1 0
- * address_mask: 1 1 0
- */
- decode_mask &= address_mask;
- new_mask = decode_mask;
-
- /*
- * We start by setting the decode_mask bits to different values
- * when a conflict is found the address_mask of the conflicting
- * resource is returned. We remove those bits from decode_mask
- * that are also set in the returned address_mask as they always
- * conflict with resources which use them as address masks.
- * The resoulting mask is stored in new_mask.
- * We continue until no conflict is found or until we have
- * tried all possible settings of new_mask.
- */
- while (1) {
- base = make_base(counter,new_mask) | fixed_bits;
- RANGE(r,base,address_mask,type);
- conflict = ChkConflict(&r,Acc,SETUP);
- if (!conflict) {
- conflict = ChkConflict(&r,avoid,SETUP);
- if (!conflict) {
- return r;
- }
- }
- counter = fix_counter(counter,new_mask,conflict);
- max_counter = fix_counter(max_counter,new_mask,conflict);
- new_mask &= conflict;
- counter ++;
- if (counter > max_counter) break;
- }
- if (!new_mask && (new_mask == decode_mask)) {
- RANGE(r,0,0,ResEnd);
- return r;
- }
- /*
- * if we haven't been successful we also try to modify those
- * bits in decode_mask that are not at the same time set in
- * new mask. These bits overlap with address_bits of some
- * resources. If a conflict with a resource of this kind is
- * found (ie. returned_mask & mask1 != mask1) with
- * mask1 = decode_mask & ~new_mask we cannot
- * use our choice of bits in the new_mask part. We try
- * another choice.
- */
- max_counter = fix_counter(mt_max,mt_max,new_mask);
- mask1 = decode_mask & ~new_mask;
- max_counter1 = fix_counter(mt_max,mt_max,mask1);
- counter = 0;
-
- while (1) {
- counter1 = 0;
- while (1) {
- base = make_base(counter1,mask1);
- RANGE(r,base,address_mask,type);
- conflict = ChkConflict(&r,Acc,SETUP);
- if (!conflict) {
- conflict = ChkConflict(&r,avoid,SETUP);
- if (!conflict) {
- return r;
- }
- }
- counter1 ++;
- if ((mask1 & conflict) != mask1 || counter1 > max_counter1)
- break;
- }
- counter ++;
- if (counter > max_counter) break;
- }
- RANGE(r,0,0,ResEnd);
- return r;
-}
-
-#undef length
-#undef mt_max
-
-/*
- * Resource registrarion
- */
-
-static resList
-xf86GetResourcesImplicitly(int entityIndex)
-{
- if (entityIndex >= xf86NumEntities) return NULL;
-
- switch (xf86Entities[entityIndex]->bus.type) {
- case BUS_ISA:
- case BUS_NONE:
- case BUS_SBUS:
- return NULL;
- case BUS_PCI:
- return GetImplicitPciResources(entityIndex);
- case BUS_last:
- return NULL;
- }
- return NULL;
-}
-
-static void
-convertRange2Host(int entityIndex, resRange *pRange)
-{
- if (pRange->type & ResBus) {
- switch (xf86Entities[entityIndex]->busType) {
- case BUS_PCI:
- pciConvertRange2Host(entityIndex,pRange);
- break;
- case BUS_ISA:
- isaConvertRange2Host(pRange);
- break;
- default:
- break;
- }
-
- pRange->type &= ~ResBus;
- }
-}
-
-/*
- * xf86RegisterResources() -- attempts to register listed resources.
- * If list is NULL it tries to obtain resources implicitly. Function
- * returns a resPtr listing all resources not successfully registered.
- */
-
-resPtr
-xf86RegisterResources(int entityIndex, resList list, unsigned long access)
-{
- resPtr res = NULL;
- resRange range;
- resList list_f = NULL;
-
- if (!list) {
- list = xf86GetResourcesImplicitly(entityIndex);
- /* these resources have to be in host address space already */
- if (!list) return NULL;
- list_f = list;
- }
-
- while(list->type != ResEnd) {
- range = *list;
-
- convertRange2Host(entityIndex,&range);
-
- if ((access != ResNone) && (access & ResAccMask)) {
- range.type = (range.type & ~ResAccMask) | (access & ResAccMask);
- }
- range.type &= ~ResEstimated; /* Not allowed for drivers */
-#if !((defined(__alpha__) || (defined(__ia64__))) && defined(linux))
- /* On Alpha Linux, do not check for conflicts, trust the kernel. */
- if (checkConflict(&range, Acc, entityIndex, SETUP,TRUE))
- res = xf86AddResToList(res,&range,entityIndex);
- else
-#endif
- {
- Acc = xf86AddResToList(Acc,&range,entityIndex);
- }
- list++;
- }
- if (list_f)
- xfree(list_f);
-
-#ifdef DEBUG
- xf86MsgVerb(X_INFO, 3,"Resources after driver initialization\n");
- xf86PrintResList(3, Acc);
- if (res) xf86MsgVerb(X_INFO, 3,
- "Failed Resources after driver initialization "
- "for Entity: %i\n",entityIndex);
- xf86PrintResList(3, res);
-#endif
- return res;
-
-}
-
-static void
-busTypeSpecific(EntityPtr pEnt, xf86State state, xf86AccessPtr *acc_mem,
- xf86AccessPtr *acc_io, xf86AccessPtr *acc_mem_io)
-{
- pciAccPtr *ppaccp;
-
- switch (pEnt->bus.type) {
- case BUS_ISA:
- case BUS_SBUS:
- *acc_mem = *acc_io = *acc_mem_io = &AccessNULL;
- break;
- break;
- case BUS_PCI:
- ppaccp = xf86PciAccInfo;
- while (*ppaccp) {
- if ((*ppaccp)->busnum == pEnt->pciBusId.bus
- && (*ppaccp)->devnum == pEnt->pciBusId.device
- && (*ppaccp)->funcnum == pEnt->pciBusId.func) {
- *acc_io = &(*ppaccp)->ioAccess;
- *acc_mem = &(*ppaccp)->memAccess;
- *acc_mem_io = &(*ppaccp)->io_memAccess;
- break;
- }
- ppaccp++;
- }
- break;
- default:
- *acc_mem = *acc_io = *acc_mem_io = NULL;
- break;
- }
- return;
-}
-
-static void
-setAccess(EntityPtr pEnt, xf86State state)
-{
-
- xf86AccessPtr acc_mem, acc_io, acc_mem_io;
- xf86AccessPtr org_mem = NULL, org_io = NULL, org_mem_io = NULL;
- int prop;
-
- busTypeSpecific(pEnt,state,&acc_mem,&acc_io,&acc_mem_io);
-
- /* The replacement function needs to handle _all_ shared resources */
- /* unless they are handeled locally and disabled otherwise */
- if (pEnt->rac) {
- if (pEnt->rac->io_new) {
- org_io = acc_io;
- acc_io = pEnt->rac->io_new;
- }
- if (pEnt->rac->mem_new) {
- org_mem = acc_mem;
- acc_mem = pEnt->rac->mem_new;
- }
- if (pEnt->rac->io_mem_new) {
- org_mem_io = acc_mem_io;
- acc_mem_io = pEnt->rac->io_mem_new;
- }
- }
-
- if (state == OPERATING) {
- prop = pEnt->entityProp;
- switch(pEnt->entityProp & NEED_SHARED) {
- case NEED_SHARED:
- pEnt->access->rt = MEM_IO;
- break;
- case NEED_IO_SHARED:
- pEnt->access->rt = IO;
- break;
- case NEED_MEM_SHARED:
- pEnt->access->rt = MEM;
- break;
- default:
- pEnt->access->rt = NONE;
- }
- } else {
- prop = NEED_SHARED | NEED_MEM | NEED_IO;
- pEnt->access->rt = MEM_IO;
- }
-
- switch(pEnt->access->rt) {
- case IO:
- pEnt->access->pAccess = acc_io;
- break;
- case MEM:
- pEnt->access->pAccess = acc_mem;
- break;
- case MEM_IO:
- pEnt->access->pAccess = acc_mem_io;
- break;
- default: /* no conflicts at all */
- pEnt->access->pAccess = NULL; /* remove from RAC */
- break;
- }
-
- if (org_io) {
- /* does the driver want the old access func? */
- if (pEnt->rac->old) {
- /* give it to the driver, leave state disabled */
- pEnt->rac->old->io = org_io;
- } else if (org_io->AccessEnable) {
- /* driver doesn't want it - enable generic access */
- org_io->AccessEnable(org_io->arg);
- }
- }
-
- if (org_mem_io) {
- /* does the driver want the old access func? */
- if (pEnt->rac->old) {
- /* give it to the driver, leave state disabled */
- pEnt->rac->old->io_mem = org_mem_io;
- } else if (org_mem_io->AccessEnable) {
- /* driver doesn't want it - enable generic access */
- org_mem_io->AccessEnable(org_mem_io->arg);
- }
- }
-
- if (org_mem) {
- /* does the driver want the old access func? */
- if (pEnt->rac->old) {
- /* give it to the driver, leave state disabled */
- pEnt->rac->old->mem = org_mem;
- } else if (org_mem->AccessEnable) {
- /* driver doesn't want it - enable generic access */
- org_mem->AccessEnable(org_mem->arg);
- }
- }
-
- if (!(prop & NEED_MEM_SHARED)){
- if (prop & NEED_MEM) {
- if (acc_mem && acc_mem->AccessEnable)
- acc_mem->AccessEnable(acc_mem->arg);
- } else {
- if (acc_mem && acc_mem->AccessDisable)
- acc_mem->AccessDisable(acc_mem->arg);
- }
- }
-
- if (!(prop & NEED_IO_SHARED)) {
- if (prop & NEED_IO) {
- if (acc_io && acc_io->AccessEnable)
- acc_io->AccessEnable(acc_io->arg);
- } else {
- if (acc_io && acc_io->AccessDisable)
- acc_io->AccessDisable(acc_io->arg);
- }
- }
-
- /* disable shared resources */
- if (pEnt->access->pAccess
- && pEnt->access->pAccess->AccessDisable)
- pEnt->access->pAccess->AccessDisable(pEnt->access->pAccess->arg);
-
- /*
- * If device is not under access control it is enabled.
- * If it needs bus routing do it here as it isn't bus
- * type specific. Any conflicts should be checked at this
- * stage
- */
- if (!pEnt->access->pAccess
- && (pEnt->entityProp & (state == SETUP ? NEED_VGA_ROUTED_SETUP :
- NEED_VGA_ROUTED)))
- ((BusAccPtr)pEnt->busAcc)->set_f(pEnt->busAcc);
-}
-
-
-/*
- * xf86EnterServerState() -- set state the server is in.
- */
-
-typedef enum { TRI_UNSET, TRI_TRUE, TRI_FALSE } TriState;
-
-static void
-SetSIGIOForState(xf86State state)
-{
- static int sigio_state;
- static TriState sigio_blocked = TRI_UNSET;
-
- if ((state == SETUP) && (sigio_blocked != TRI_TRUE)) {
- sigio_state = xf86BlockSIGIO();
- sigio_blocked = TRI_TRUE;
- } else if ((state == OPERATING) && (sigio_blocked != TRI_UNSET)) {
- xf86UnblockSIGIO(sigio_state);
- sigio_blocked = TRI_FALSE;
- }
-}
-
-void
-xf86EnterServerState(xf86State state)
-{
- EntityPtr pEnt;
- ScrnInfoPtr pScrn;
- int i,j;
- int needVGA = 0;
- resType rt;
- /*
- * This is a good place to block SIGIO during SETUP state.
- * SIGIO should be blocked in SETUP state otherwise (u)sleep()
- * might get interrupted early.
- * We take care not to call xf86BlockSIGIO() twice.
- */
- SetSIGIOForState(state);
-#ifdef DEBUG
- if (state == SETUP)
- ErrorF("Entering SETUP state\n");
- else
- ErrorF("Entering OPERATING state\n");
-#endif
-
- /* When servicing a dumb framebuffer we don't need to do anything */
- if (doFramebufferMode) return;
-
- for (i=0; i<xf86NumScreens; i++) {
- pScrn = xf86Screens[i];
- j = pScrn->entityList[pScrn->numEntities - 1];
- pScrn->access = xf86Entities[j]->access;
-
- for (j = 0; j<xf86Screens[i]->numEntities; j++) {
- pEnt = xf86Entities[xf86Screens[i]->entityList[j]];
- if (pEnt->entityProp & (state == SETUP ? NEED_VGA_ROUTED_SETUP
- : NEED_VGA_ROUTED))
- xf86Screens[i]->busAccess = pEnt->busAcc;
- }
- if (xf86Screens[i]->busAccess)
- needVGA ++;
- }
-
- /*
- * if we just have one screen we don't have RAC.
- * Therefore just enable the screen and return.
- */
- if (!needRAC) {
- xf86EnableAccess(xf86Screens[0]);
- notifyStateChange(NOTIFY_ENABLE);
- return;
- }
-
- if (state == SETUP)
- notifyStateChange(NOTIFY_SETUP_TRANSITION);
- else
- notifyStateChange(NOTIFY_OPERATING_TRANSITION);
-
- clearAccess();
- for (i=0; i<xf86NumScreens;i++) {
-
- rt = NONE;
-
- for (j = 0; j<xf86Screens[i]->numEntities; j++) {
- pEnt = xf86Entities[xf86Screens[i]->entityList[j]];
- setAccess(pEnt,state);
-
- if (pEnt->access->rt != NONE) {
- if (rt != NONE && rt != pEnt->access->rt)
- rt = MEM_IO;
- else
- rt = pEnt->access->rt;
- }
- }
- xf86Screens[i]->resourceType = rt;
- if (rt == NONE) {
- xf86Screens[i]->access = NULL;
- if (needVGA < 2)
- xf86Screens[i]->busAccess = NULL;
- }
-
-#ifdef DEBUG
- if (xf86Screens[i]->busAccess)
- ErrorF("Screen %i setting vga route\n",i);
-#endif
- switch (rt) {
- case MEM_IO:
- xf86MsgVerb(X_INFO, 3, "Screen %i shares mem & io resources\n",i);
- break;
- case IO:
- xf86MsgVerb(X_INFO, 3, "Screen %i shares io resources\n",i);
- break;
- case MEM:
- xf86MsgVerb(X_INFO, 3, "Screen %i shares mem resources\n",i);
- break;
- default:
- xf86MsgVerb(X_INFO, 3, "Entity %i shares no resources\n",i);
- break;
- }
- }
- if (state == SETUP)
- notifyStateChange(NOTIFY_SETUP);
- else
- notifyStateChange(NOTIFY_OPERATING);
-}
-
-/*
- * xf86SetOperatingState() -- Set ResOperMask for resources listed.
- */
-resPtr
-xf86SetOperatingState(resList list, int entityIndex, int mask)
-{
- resPtr acc;
- resPtr r_fail = NULL;
- resRange range;
-
- while (list->type != ResEnd) {
- range = *list;
- convertRange2Host(entityIndex,&range);
-
- acc = Acc;
- while (acc) {
-#define MASK (ResTypeMask | ResExtMask)
- if ((acc->entityIndex == entityIndex)
- && (acc->val.a == range.a) && (acc->val.b == range.b)
- && ((acc->val.type & MASK) == (range.type & MASK)))
- break;
-#undef MASK
- acc = acc->next;
- }
- if (acc)
- acc->val.type = (acc->val.type & ~ResOprMask)
- | (mask & ResOprMask);
- else {
- r_fail = xf86AddResToList(r_fail,&range,entityIndex);
- }
- list ++;
- }
-
- return r_fail;
-}
-
-/*
- * Stage specific code
- */
- /*
- * ProcessEstimatedConflicts() -- Do something about driver-registered
- * resources that conflict with estimated resources. For now, just register
- * them with a logged warning.
- */
-#ifdef REDUCER
-static void
-ProcessEstimatedConflicts(void)
-{
- if (!AccReducers)
- return;
-
- /* Temporary */
- xf86MsgVerb(X_WARNING, 3,
- "Registering the following despite conflicts with estimated"
- " resources:\n");
- xf86PrintResList(3, AccReducers);
- Acc = xf86JoinResLists(Acc, AccReducers);
- AccReducers = NULL;
-}
-#endif
-
-/*
- * xf86ClaimFixedResources() -- This function gets called from the
- * driver Probe() function to claim fixed resources.
- */
-static void
-resError(resList list)
-{
- FatalError("A driver tried to allocate the %s %sresource at \n"
- "0x%lx:0x%lx which conflicted with another resource. Send the\n"
- "output of the server to %s. Please \n"
- "specify your computer hardware as closely as possible.\n",
- ResIsBlock(list)?"Block":"Sparse",
- ResIsMem(list)?"Mem":"Io",
- ResIsBlock(list)?list->rBegin:list->rBase,
- ResIsBlock(list)?list->rEnd:list->rMask,BUILDERADDR);
-}
-
-/*
- * xf86ClaimFixedResources() is used to allocate non-relocatable resources.
- * This should only be done by a driver's Probe() function.
- */
-void
-xf86ClaimFixedResources(resList list, int entityIndex)
-{
- resPtr ptr = NULL;
- resRange range;
-
- if (!list) return;
-
- while (list->type !=ResEnd) {
- range = *list;
-
- convertRange2Host(entityIndex,&range);
-
- range.type &= ~ResEstimated; /* Not allowed for drivers */
- switch (range.type & ResAccMask) {
- case ResExclusive:
- if (!xf86ChkConflict(&range, entityIndex)) {
- Acc = xf86AddResToList(Acc, &range, entityIndex);
-#ifdef REDUCER
- } else {
- range.type |= ResEstimated;
- if (!xf86ChkConflict(&range, entityIndex) &&
- !checkConflict(&range, AccReducers, entityIndex,
- SETUP, FALSE)) {
- range.type &= ~(ResEstimated | ResBios);
- AccReducers =
- xf86AddResToList(AccReducers, &range, entityIndex);
-#endif
- } else resError(&range); /* no return */
-#ifdef REDUCER
- }
-#endif
- break;
- case ResShared:
- /* at this stage the resources are just added to the
- * EntityRec. After the Probe() phase this list is checked by
- * xf86PostProbe(). All resources which don't
- * conflict with already allocated ones are allocated
- * and removed from the EntityRec. Thus a non-empty resource
- * list in the EntityRec indicates resource conflicts the
- * driver should either handle or fail.
- */
- if (xf86Entities[entityIndex]->active)
- ptr = xf86AddResToList(ptr,&range,entityIndex);
- break;
- }
- list++;
- }
- xf86Entities[entityIndex]->resources =
- xf86JoinResLists(xf86Entities[entityIndex]->resources,ptr);
- xf86MsgVerb(X_INFO, 3,
- "resource ranges after xf86ClaimFixedResources() call:\n");
- xf86PrintResList(3,Acc);
-#ifdef REDUCER
- ProcessEstimatedConflicts();
-#endif
-#ifdef DEBUG
- if (ptr) {
- xf86MsgVerb(X_INFO, 3, "to be registered later:\n");
- xf86PrintResList(3,ptr);
- }
-#endif
-}
-
-static void
-checkRoutingForScreens(xf86State state)
-{
- resList list = resVgaUnusedExclusive;
- resPtr pResVGA = NULL;
- resPtr pResVGAHost;
- pointer vga = NULL;
- int i,j;
- int entityIndex;
- EntityPtr pEnt;
- resPtr pAcc;
- resRange range;
-
- /*
- * find devices that need VGA routed: ie the ones that have
- * registered VGA resources without ResUnused. ResUnused
- * doesn't conflict with itself therefore use it here.
- */
- while (list->type != ResEnd) { /* create resPtr from resList for VGA */
- range = *list;
- range.type &= ~(ResBios | ResEstimated); /* if set remove them */
- pResVGA = xf86AddResToList(pResVGA, &range, -1);
- list++;
- }
-
- for (i = 0; i < xf86NumScreens; i++) {
- for (j = 0; j < xf86Screens[i]->numEntities; j++) {
- entityIndex = xf86Screens[i]->entityList[j];
- pEnt = xf86Entities[entityIndex];
- pAcc = Acc;
- vga = NULL;
- pResVGAHost = xf86DupResList(pResVGA);
- xf86ConvertListToHost(entityIndex,pResVGAHost);
- while (pAcc) {
- if (pAcc->entityIndex == entityIndex)
- if (checkConflict(&pAcc->val, pResVGAHost,
- entityIndex, state, FALSE)) {
- if (vga && vga != pEnt->busAcc) {
- xf86Msg(X_ERROR, "Screen %i needs vga routed to"
- "different buses - deleting\n",i);
- xf86DeleteScreen(i--,0);
- }
-#ifdef DEBUG
- {
- resPtr rlist = xf86AddResToList(NULL,&pAcc->val,
- pAcc->entityIndex);
- xf86MsgVerb(X_INFO,3,"====== %s\n",
- state == OPERATING ? "OPERATING"
- : "SETUP");
- xf86MsgVerb(X_INFO,3,"%s Resource:\n",
- (pAcc->val.type) & ResMem ? "Mem" :"Io");
- xf86PrintResList(3,rlist);
- xf86FreeResList(rlist);
- xf86MsgVerb(X_INFO,3,"Conflicts with:\n");
- xf86PrintResList(3,pResVGAHost);
- xf86MsgVerb(X_INFO,3,"=====\n");
- }
-#endif
- vga = pEnt->busAcc;
- pEnt->entityProp |= (state == SETUP
- ? NEED_VGA_ROUTED_SETUP : NEED_VGA_ROUTED);
- if (state == OPERATING) {
- if (pAcc->val.type & ResMem)
- pEnt->entityProp |= NEED_VGA_MEM;
- else
- pEnt->entityProp |= NEED_VGA_IO;
- }
- }
- pAcc = pAcc->next;
- }
- if (vga)
- xf86MsgVerb(X_INFO, 3,"Setting vga for screen %i.\n",i);
- xf86FreeResList(pResVGAHost);
- }
- }
- xf86FreeResList(pResVGA);
-}
-
-/*
- * xf86PostProbe() -- Allocate all non conflicting resources
- * This function gets called by xf86Init().
- */
-void
-xf86PostProbe(void)
-{
- memType val;
- int i,j;
- resPtr resp, acc, tmp, resp_x, *pprev_next;
-
- if (fbSlotClaimed) {
- if (pciSlotClaimed || isaSlotClaimed
-#if defined(__sparc__) && !defined(__OpenBSD__)
- || sbusSlotClaimed
-#endif
- ) {
- FatalError("Cannot run in framebuffer mode. Please specify busIDs "
- " for all framebuffer devices\n");
- return;
- } else {
- xf86Msg(X_INFO,"Running in FRAMEBUFFER Mode\n");
- xf86AccessRestoreState();
- notifyStateChange(NOTIFY_ENABLE);
- doFramebufferMode = TRUE;
-
- return;
- }
- }
- /* don't compare against ResInit - remove it from clone.*/
- acc = tmp = xf86DupResList(Acc);
- pprev_next = &acc;
- while (tmp) {
- if (tmp->res_type & ResInit) {
- (*pprev_next) = tmp->next;
- xfree(tmp);
- } else
- pprev_next = &(tmp->next);
- tmp = (*pprev_next);
- }
-
- for (i=0; i<xf86NumEntities; i++) {
- resp = xf86Entities[i]->resources;
- xf86Entities[i]->resources = NULL;
- resp_x = NULL;
- while (resp) {
- if (! (val = checkConflict(&resp->val,acc,i,SETUP,FALSE))) {
- resp->res_type &= ~(ResBios); /* just used for chkConflict() */
- tmp = resp_x;
- resp_x = resp;
- resp = resp->next;
- resp_x->next = tmp;
-#ifdef REDUCER
- } else {
- resp->res_type |= ResEstimated;
- if (!checkConflict(&resp->val, acc, i, SETUP, FALSE)) {
- resp->res_type &= ~(ResEstimated | ResBios);
- tmp = AccReducers;
- AccReducers = resp;
- resp = resp->next;
- AccReducers->next = tmp;
-#endif
- } else {
- xf86MsgVerb(X_INFO, 3, "Found conflict at: 0x%lx\n",val);
- resp->res_type &= ~ResEstimated;
- tmp = xf86Entities[i]->resources;
- xf86Entities[i]->resources = resp;
- resp = resp->next;
- xf86Entities[i]->resources->next = tmp;
- }
-#ifdef REDUCER
- }
-#endif
- }
- xf86JoinResLists(Acc,resp_x);
-#ifdef REDUCER
- ProcessEstimatedConflicts();
-#endif
- }
- xf86FreeResList(acc);
-#if !(defined(__alpha__) && defined(linux)) && \
- !(defined(__ia64__) && defined(linux)) && \
- !(defined(__sparc64__) && defined(__OpenBSD__))
- /*
- * No need to validate on Alpha Linux or OpenBSD/sparc64,
- * trust the kernel.
- */
- ValidatePci();
-#endif
-
- xf86MsgVerb(X_INFO, 3, "resource ranges after probing:\n");
- xf86PrintResList(3, Acc);
- checkRoutingForScreens(SETUP);
-
- for (i = 0; i < xf86NumScreens; i++) {
- for (j = 0; j<xf86Screens[i]->numEntities; j++) {
- EntityPtr pEnt = xf86Entities[xf86Screens[i]->entityList[j]];
- if ((pEnt->entityProp & NEED_VGA_ROUTED_SETUP) &&
- ((xf86Screens[i]->busAccess = pEnt->busAcc)))
- break;
- }
- }
-}
-
-static void
-checkRequiredResources(int entityIndex)
-{
- resRange range;
- resPtr pAcc = Acc;
- const EntityPtr pEnt = xf86Entities[entityIndex];
- while (pAcc) {
- if (pAcc->entityIndex == entityIndex) {
- range = pAcc->val;
- /* ResAny to find conflicts with anything. */
- range.type = (range.type & ~ResAccMask) | ResAny | ResBios;
- if (checkConflict(&range,Acc,entityIndex,OPERATING,FALSE))
- switch (pAcc->res_type & ResPhysMask) {
- case ResMem:
- pEnt->entityProp |= NEED_MEM_SHARED;
- break;
- case ResIo:
- pEnt->entityProp |= NEED_IO_SHARED;
- break;
- }
- if (!(pAcc->res_type & ResOprMask)) {
- switch (pAcc->res_type & ResPhysMask) {
- case ResMem:
- pEnt->entityProp |= NEED_MEM;
- break;
- case ResIo:
- pEnt->entityProp |= NEED_IO;
- break;
- }
- }
- }
- pAcc = pAcc->next;
- }
-
- /* check if we can separately enable mem/io resources */
- /* XXX we still need to find out how to set this yet */
- if ( ((pEnt->entityProp & NO_SEPARATE_MEM_FROM_IO)
- && (pEnt->entityProp & NEED_MEM_SHARED))
- || ((pEnt->entityProp & NO_SEPARATE_IO_FROM_MEM)
- && (pEnt->entityProp & NEED_IO_SHARED)) )
- pEnt->entityProp |= NEED_SHARED;
- /*
- * After we have checked all resources of an entity agains any
- * other resource we know if the entity need this resource type
- * (ie. mem/io) at all. if not we can disable this type completely,
- * so no need to share it either.
- */
- if ((pEnt->entityProp & NEED_MEM_SHARED)
- && (!(pEnt->entityProp & NEED_MEM))
- && (!(pEnt->entityProp & NO_SEPARATE_MEM_FROM_IO)))
- pEnt->entityProp &= ~(unsigned long)NEED_MEM_SHARED;
-
- if ((pEnt->entityProp & NEED_IO_SHARED)
- && (!(pEnt->entityProp & NEED_IO))
- && (!(pEnt->entityProp & NO_SEPARATE_IO_FROM_MEM)))
- pEnt->entityProp &= ~(unsigned long)NEED_IO_SHARED;
-}
-
-void
-xf86PostPreInit()
-{
- if (doFramebufferMode) return;
-
- if (xf86NumScreens > 1)
- needRAC = TRUE;
-
-#ifdef XFree86LOADER
- xf86MsgVerb(X_INFO, 3, "do I need RAC?");
-
- if (needRAC) {
- xf86ErrorFVerb(3, " Yes, I do.\n");
-
- if (!xf86LoadOneModule("rac",NULL))
- FatalError("Cannot load RAC module\n");
- } else
- xf86ErrorFVerb(3, " No, I don't.\n");
-#endif
-
- xf86MsgVerb(X_INFO, 3, "resource ranges after preInit:\n");
- xf86PrintResList(3, Acc);
-}
-
-void
-xf86PostScreenInit(void)
-{
- int i,j;
- ScreenPtr pScreen;
- unsigned int flags;
- int nummem = 0, numio = 0;
-#ifdef XFree86LOADER
- pointer xf86RACInit = NULL;
-#endif
-
- if (doFramebufferMode) {
- SetSIGIOForState(OPERATING);
- return;
- }
-
-#ifdef XFree86LOADER
- if (needRAC) {
- xf86RACInit = LoaderSymbol("xf86RACInit");
- if (!xf86RACInit)
- FatalError("Cannot resolve symbol \"xf86RACInit\"\n");
- }
-#endif
-#ifdef DEBUG
- ErrorF("PostScreenInit generation: %i\n",serverGeneration);
-#endif
- if (serverGeneration == 1) {
- checkRoutingForScreens(OPERATING);
- for (i=0; i<xf86NumEntities; i++) {
- checkRequiredResources(i);
- }
-
- /*
- * after removing NEED_XXX_SHARED from entities that
- * don't need need XXX resources at all we might have
- * a single entity left that has NEED_XXX_SHARED set.
- * In this case we can delete that, too.
- */
- for (i = 0; i < xf86NumEntities; i++) {
- if (xf86Entities[i]->entityProp & NEED_MEM_SHARED)
- nummem++;
- if (xf86Entities[i]->entityProp & NEED_IO_SHARED)
- numio++;
- }
- for (i = 0; i < xf86NumEntities; i++) {
- if (nummem < 2)
- xf86Entities[i]->entityProp &= ~NEED_MEM_SHARED;
- if (numio < 2)
- xf86Entities[i]->entityProp &= ~NEED_IO_SHARED;
- }
- }
-
- if (xf86Screens && needRAC) {
- int needRACforVga = 0;
-
- for (i = 0; i < xf86NumScreens; i++) {
- for (j = 0; j < xf86Screens[i]->numEntities; j++) {
- if (xf86Entities[xf86Screens[i]->entityList[j]]->entityProp
- & NEED_VGA_ROUTED) {
- needRACforVga ++;
- break; /* only count each screen once */
- }
- }
- }
-
- for (i = 0; i < xf86NumScreens; i++) {
- Bool needRACforMem = FALSE, needRACforIo = FALSE;
-
- for (j = 0; j < xf86Screens[i]->numEntities; j++) {
- if (xf86Entities[xf86Screens[i]->entityList[j]]->entityProp
- & NEED_MEM_SHARED)
- needRACforMem = TRUE;
- if (xf86Entities[xf86Screens[i]->entityList[j]]->entityProp
- & NEED_IO_SHARED)
- needRACforIo = TRUE;
- /*
- * We may need RAC although we don't share any resources
- * as we need to route VGA to the correct bus. This can
- * only be done simultaniously for MEM and IO.
- */
- if (needRACforVga > 1) {
- if (xf86Entities[xf86Screens[i]->entityList[j]]->entityProp
- & NEED_VGA_MEM)
- needRACforMem = TRUE;
- if (xf86Entities[xf86Screens[i]->entityList[j]]->entityProp
- & NEED_VGA_IO)
- needRACforIo = TRUE;
- }
- }
-
- pScreen = xf86Screens[i]->pScreen;
- flags = 0;
- if (needRACforMem) {
- flags |= xf86Screens[i]->racMemFlags;
- xf86ErrorFVerb(3, "Screen %d is using RAC for mem\n", i);
- }
- if (needRACforIo) {
- flags |= xf86Screens[i]->racIoFlags;
- xf86ErrorFVerb(3, "Screen %d is using RAC for io\n", i);
- }
-
-#ifdef XFree86LOADER
- ((Bool(*)(ScreenPtr,unsigned int))xf86RACInit)
- (pScreen,flags);
-#else
- xf86RACInit(pScreen,flags);
-#endif
- }
- }
-
- xf86EnterServerState(OPERATING);
-
-}
-
-/*
- * Sets
- */
-
-
-static resPtr
-decomposeSparse(resRange range)
-{
- resRange new;
- resPtr ret = NULL;
- memType val = range.rBegin;
- int i = 0;
-
- new.type = (range.type & ~ResExtMask) | ResSparse;
-
- while (1) {
- if (val & 0x01) {
- new.rBase = (val << i);
- new.rMask = ~((1 << i) - 1);
- ret = xf86AddResToList(ret,&new,-1);
- val ++;
- }
- i++;
- val >>= 1;
- if ((((val + 1) << i) - 1) > range.rEnd)
- break;
- }
- i--;
- val <<= 1;
-
- while (1) {
- if((((val + 1) << i) - 1)> range.rEnd) {
- if (--i < 0) break;
- val <<= 1;
- } else {
- new.rBase = (val << i);
- new.rMask = ~((1 << i) - 1);
- val++;
- ret = xf86AddResToList(ret,&new,-1);
- }
- }
- return ret;
-}
-
-static Bool
-x_isSubsetOf(resRange range, resPtr list1, resPtr list2)
-{
- resRange range1, range2;
- memType m1_A_m2;
- Bool ret;
- resPtr list;
-
- if (list1) {
- list = list1;
- if ((range.type & ResTypeMask) == (list->res_type & ResTypeMask)) {
- switch (range.type & ResExtMask) {
- case ResBlock:
- if ((list->res_type & ResExtMask) == ResBlock) {
- if (range.rBegin >= list->block_begin
- && range.rEnd <= list->block_end)
- return TRUE;
- else if (range.rBegin < list->block_begin
- && range.rEnd > list->block_end) {
- RANGE(range1, range.rBegin, list->block_begin - 1,
- range.type);
- RANGE(range2, list->block_end + 1, range.rEnd,
- range.type);
- return (x_isSubsetOf(range1,list->next,list2) &&
- x_isSubsetOf(range2,list->next,list2));
- }
- else if (range.rBegin >= list->block_begin
- && range.rBegin <= list->block_end) {
- RANGE(range1, list->block_end + 1, range.rEnd,
- range.type);
- return (x_isSubsetOf(range1,list->next,list2));
- } else if (range.rEnd >= list->block_begin
- && range.rEnd <= list->block_end) {
- RANGE(range1,range.rBegin, list->block_begin - 1,
- range.type);
- return (x_isSubsetOf(range1,list->next,list2));
- }
- }
- break;
- case ResSparse:
- if ((list->res_type & ResExtMask) == ResSparse) {
- memType test;
- int i;
-
- m1_A_m2 = range.rMask & list->sparse_mask;
- if ((range.rBase ^ list->sparse_base) & m1_A_m2)
- break;
- /*
- * We use the following system:
- * let 0 ^= mask:1 base:0, 1 ^= mask:1 base:1,
- * X mask:0 ; S: set TSS: test set for subset
- * NTSS: new test set after test
- * S: 1 0 1 0 X X 0 1 X
- * TSS: 1 0 0 1 1 0 X X X
- * T: 0 0 1 1 0 0 0 0 0
- * NTSS: 1 0 0/X 1/X 1 0 1 0 X
- * R: 0 0 0 0 0 0 1 1 0
- * If R != 0 TSS and S are disjunct
- * If R == 0 TSS is subset of S
- * If R != 0 NTSS contains elements from TSS
- * which are not also members of S.
- * If a T is set one of the correspondig bits
- * in NTSS must be set to the specified value
- * all other are X
- */
- test = list->sparse_mask & ~range.rMask;
- if (test == 0)
- return TRUE;
- for (i = 0; i < sizeof(memType); i++) {
- if ((test >> i) & 0x1) {
- RANGE(range1, ((range.rBase & list->sparse_base)
- | (range.rBase & ~list->sparse_mask)
- | ((~list->sparse_base & list->sparse_mask)
- & ~range.rMask)) & range1.rMask,
- ((range.rMask | list->sparse_mask) & ~test)
- | (1 << i), range.type);
- return (x_isSubsetOf(range1,list->next,list2));
- }
- }
- }
- break;
- }
- }
- return (x_isSubsetOf(range,list->next,list2));
- } else if (list2) {
- resPtr tmpList = NULL;
- switch (range.type & ResExtMask) {
- case ResBlock:
- tmpList = decomposeSparse(range);
- while (tmpList) {
- if (!x_isSubsetOf(tmpList->val,list2,NULL)) {
- xf86FreeResList(tmpList);
- return FALSE;
- }
- tmpList = tmpList->next;
- }
- xf86FreeResList(tmpList);
- return TRUE;
- break;
- case ResSparse:
- while (list2) {
- tmpList = xf86JoinResLists(tmpList,decomposeSparse(list2->val));
- list2 = list2->next;
- }
- ret = x_isSubsetOf(range,tmpList,NULL);
- xf86FreeResList(tmpList);
- return ret;
- break;
- }
- } else
- return FALSE;
-
- return FALSE;
-}
-
-Bool
-xf86IsSubsetOf(resRange range, resPtr list)
-{
- resPtr dup = xf86DupResList(list);
- resPtr r_sp = NULL, r = NULL, tmp = NULL;
- Bool ret = FALSE;
-
- while (dup) {
- tmp = dup;
- dup = dup->next;
- switch (tmp->res_type & ResExtMask) {
- case ResBlock:
- tmp->next = r;
- r = tmp;
- break;
- case ResSparse:
- tmp->next = r_sp;
- r_sp = tmp;
- break;
- }
- }
-
- switch (range.type & ResExtMask) {
- case ResBlock:
- ret = x_isSubsetOf(range,r,r_sp);
- break;
- case ResSparse:
- ret = x_isSubsetOf(range,r_sp,r);
- break;
- }
- xf86FreeResList(r);
- xf86FreeResList(r_sp);
-
- return ret;
-}
-
-Bool
-xf86IsListSubsetOf(resPtr list, resPtr BaseList)
-{
- while (list) {
- if (! xf86IsSubsetOf(list->val,BaseList))
- return FALSE;
- list = list->next;
- }
- return TRUE;
-}
-
-resPtr
-findIntersect(resRange Range, resPtr list)
-{
- resRange range;
- resPtr new = NULL;
-
- while (list) {
- if ((Range.type & ResTypeMask) == (list->res_type & ResTypeMask)) {
- switch (Range.type & ResExtMask) {
- case ResBlock:
- switch (list->res_type & ResExtMask) {
- case ResBlock:
- if (Range.rBegin >= list->block_begin)
- range.rBegin = Range.rBegin;
- else
- range.rBegin = list->block_begin;
- if (Range.rEnd <= list->block_end)
- range.rEnd = Range.rEnd;
- else
- range.rEnd = list->block_end;
- if (range.rEnd > range.rBegin) {
- range.type = Range.type;
- new = xf86AddResToList(new,&range,-1);
- }
- break;
- case ResSparse:
- new = xf86JoinResLists(new,xf86FindIntersectOfLists(new,decomposeSparse(list->val)));
- break;
- }
- break;
- case ResSparse:
- switch (list->res_type & ResExtMask) {
- case ResSparse:
- if (!((~(range.rBase ^ list->sparse_base)
- & (range.rMask & list->sparse_mask)))) {
- RANGE(range, (range.rBase & list->sparse_base)
- | (~range.rMask & list->sparse_base)
- | (~list->sparse_mask & range.rBase),
- range.rMask | list->sparse_mask,
- Range.type);
- new = xf86AddResToList(new,&range,-1);
- }
- break;
- case ResBlock:
- new = xf86JoinResLists(new,xf86FindIntersectOfLists(
- decomposeSparse(range),list));
- break;
- }
- }
- }
- list = list->next;
- }
- return new;
-}
-
-resPtr
-xf86FindIntersectOfLists(resPtr l1, resPtr l2)
-{
- resPtr ret = NULL;
-
- while (l1) {
- ret = xf86JoinResLists(ret,findIntersect(l1->val,l2));
- l1 = l1->next;
- }
- return ret;
-}
-
-#if 0 /* Not used */
-static resPtr
-xf86FindComplement(resRange Range)
-{
- resRange range;
- memType tmp;
- resPtr new = NULL;
- int i;
-
- switch (Range.type & ResExtMask) {
- case ResBlock:
- if (Range.rBegin > 0) {
- RANGE(range, 0, Range.rBegin - 1, Range.type);
- new = xf86AddResToList(new,&range,-1);
- }
- if (Range.rEnd < (memType)~0) {
- RANGE(range,Range.rEnd + 1, (memType)~0, Range.type);
- new = xf86AddResToList(new,&range,-1);
- }
- break;
- case ResSparse:
- tmp = Range.rMask;
- for (i = 0; i < sizeof(memType); i++) {
- if (tmp & 0x1) {
- RANGE(range,(~Range.rMask & range.rMask),(1 << i), Range.type);
- new = xf86AddResToList(new,&range,-1);
- }
- }
- break;
- default:
- break;
- }
- return new;
-}
-#endif
-
-resPtr
-xf86ExtractTypeFromList(resPtr list, unsigned long type)
-{
- resPtr ret = NULL;
-
- while (list) {
- if ((list->res_type & ResTypeMask) == type)
- ret = xf86AddResToList(ret,&(list->val),list->entityIndex);
- list = list->next;
- }
- return ret;
-}
-
-/*------------------------------------------------------------*/
-static void CheckGenericGA(void);
-
-/*
- * xf86FindPrimaryDevice() - Find the display device which
- * was active when the server was started.
- */
-void
-xf86FindPrimaryDevice()
-{
- /* if no VGA device is found check for primary PCI device */
- if (primaryBus.type == BUS_NONE && xorgHWAccess)
- CheckGenericGA();
- if (primaryBus.type != BUS_NONE) {
- char *bus;
- char *loc = xnfcalloc(1,9);
- if (loc == NULL) return;
-
- switch (primaryBus.type) {
- case BUS_PCI:
- bus = "PCI";
- sprintf(loc," %2.2x:%2.2x:%1.1x",primaryBus.id.pci.bus,
- primaryBus.id.pci.device,primaryBus.id.pci.func);
- break;
- case BUS_ISA:
- bus = "ISA";
- loc[0] = '\0';
- break;
- case BUS_SBUS:
- bus = "SBUS";
- sprintf(loc," %2.2x",primaryBus.id.sbus.fbNum);
- break;
- default:
- bus = "";
- loc[0] = '\0';
- }
-
- xf86MsgVerb(X_INFO, 2, "Primary Device is: %s%s\n",bus,loc);
- xfree(loc);
- }
-
-}
-
-#if !defined(__sparc__) && !defined(__powerpc__) && !defined(__mips__)
-#include "vgaHW.h"
-#include "compiler.h"
-#endif
-
-/*
- * CheckGenericGA() - Check for presence of a VGA device.
- */
-static void
-CheckGenericGA()
-{
-/* This needs to be changed for multiple domains */
-#if !defined(__sparc__) && !defined(__powerpc__) && !defined(__mips__) && !defined(__ia64__)
- IOADDRESS GenericIOBase = VGAHW_GET_IOBASE();
- CARD8 CurrentValue, TestValue;
-
- /* VGA CRTC registers are not used here, so don't bother unlocking them */
-
- /* VGA has one more read/write attribute register than EGA */
- (void) inb(GenericIOBase + VGA_IN_STAT_1_OFFSET); /* Reset flip-flop */
- outb(VGA_ATTR_INDEX, 0x14 | 0x20);
- CurrentValue = inb(VGA_ATTR_DATA_R);
- outb(VGA_ATTR_DATA_W, CurrentValue ^ 0x0F);
- outb(VGA_ATTR_INDEX, 0x14 | 0x20);
- TestValue = inb(VGA_ATTR_DATA_R);
- outb(VGA_ATTR_DATA_W, CurrentValue);
-
- if ((CurrentValue ^ 0x0F) == TestValue) {
- primaryBus.type = BUS_ISA;
- }
-#endif
-}
-
-Bool
-xf86NoSharedResources(int screenIndex,resType res)
-{
- int j;
-
- if (screenIndex > xf86NumScreens)
- return TRUE;
-
- for (j = 0; j < xf86Screens[screenIndex]->numEntities; j++) {
- switch (res) {
- case IO:
- if ( xf86Entities[xf86Screens[screenIndex]->entityList[j]]->entityProp
- & NEED_IO_SHARED)
- return FALSE;
- break;
- case MEM:
- if ( xf86Entities[xf86Screens[screenIndex]->entityList[j]]->entityProp
- & NEED_MEM_SHARED)
- return FALSE;
- break;
- case MEM_IO:
- if ( xf86Entities[xf86Screens[screenIndex]->entityList[j]]->entityProp
- & NEED_SHARED)
- return FALSE;
- break;
- case NONE:
- break;
- }
- }
- return TRUE;
-}
-
-void
-xf86ConvertListToHost(int entityIndex, resPtr list)
-{
- while (list) {
- convertRange2Host(entityIndex, &list->val);
- list = list->next;
- }
-}
-
-void
-xf86RegisterStateChangeNotificationCallback(xf86StateChangeNotificationCallbackFunc func, pointer arg)
-{
- StateChangeNotificationPtr ptr =
- (StateChangeNotificationPtr)xnfalloc(sizeof(StateChangeNotificationRec));
-
- ptr->func = func;
- ptr->arg = arg;
- ptr->next = StateChangeNotificationList;
- StateChangeNotificationList = ptr;
-}
-
-Bool
-xf86DeregisterStateChangeNotificationCallback(xf86StateChangeNotificationCallbackFunc func)
-{
- StateChangeNotificationPtr *ptr = &StateChangeNotificationList;
- StateChangeNotificationPtr tmp;
-
- while (*ptr) {
- if ((*ptr)->func == func) {
- tmp = (*ptr);
- (*ptr) = (*ptr)->next;
- xfree(tmp);
- return TRUE;
- }
- ptr = &((*ptr)->next);
- }
- return FALSE;
-}
-
-static void
-notifyStateChange(xf86NotifyState state)
-{
- StateChangeNotificationPtr ptr = StateChangeNotificationList;
- while (ptr) {
- ptr->func(state,ptr->arg);
- ptr = ptr->next;
- }
-}
-
-#ifdef async
-Bool
-xf86QueueAsyncEvent(void (*func)(pointer),pointer arg)
-{
- AsyncQPtr new;
-
- if (!AsyncQ) return FALSE;
-
- new = (AsyncQPtr)xfnalloc(sizeof(AsyncQRec));
- new->func = func;
- new->arg = arg;
- (*AsyncQPtr)->next = new;
- AsyncQPtr = &new;
- return TRUE;
-}
-#endif
-
-/* Multihead accel sharing accessor functions and entity Private handling */
-
-int
-xf86GetLastScrnFlag(int entityIndex)
-{
- if(entityIndex < xf86NumEntities) {
- return(xf86Entities[entityIndex]->lastScrnFlag);
- } else {
- return -1;
- }
-}
-
-void
-xf86SetLastScrnFlag(int entityIndex, int scrnIndex)
-{
- if(entityIndex < xf86NumEntities) {
- xf86Entities[entityIndex]->lastScrnFlag = scrnIndex;
- }
-}
-
-Bool
-xf86IsEntityShared(int entityIndex)
-{
- if(entityIndex < xf86NumEntities) {
- if(xf86Entities[entityIndex]->entityProp & IS_SHARED_ACCEL) {
- return TRUE;
- }
- }
- return FALSE;
-}
-
-void
-xf86SetEntityShared(int entityIndex)
-{
- if(entityIndex < xf86NumEntities) {
- xf86Entities[entityIndex]->entityProp |= IS_SHARED_ACCEL;
- }
-}
-
-Bool
-xf86IsEntitySharable(int entityIndex)
-{
- if(entityIndex < xf86NumEntities) {
- if(xf86Entities[entityIndex]->entityProp & ACCEL_IS_SHARABLE) {
- return TRUE;
- }
- }
- return FALSE;
-}
-
-void
-xf86SetEntitySharable(int entityIndex)
-{
- if(entityIndex < xf86NumEntities) {
- xf86Entities[entityIndex]->entityProp |= ACCEL_IS_SHARABLE;
- }
-}
-
-Bool
-xf86IsPrimInitDone(int entityIndex)
-{
- if(entityIndex < xf86NumEntities) {
- if(xf86Entities[entityIndex]->entityProp & SA_PRIM_INIT_DONE) {
- return TRUE;
- }
- }
- return FALSE;
-}
-
-void
-xf86SetPrimInitDone(int entityIndex)
-{
- if(entityIndex < xf86NumEntities) {
- xf86Entities[entityIndex]->entityProp |= SA_PRIM_INIT_DONE;
- }
-}
-
-void
-xf86ClearPrimInitDone(int entityIndex)
-{
- if(entityIndex < xf86NumEntities) {
- xf86Entities[entityIndex]->entityProp &= ~SA_PRIM_INIT_DONE;
- }
-}
-
-
-/*
- * Allocate a private in the entities.
- */
-
-int
-xf86AllocateEntityPrivateIndex(void)
-{
- int idx, i;
- EntityPtr pEnt;
- DevUnion *nprivs;
-
- idx = xf86EntityPrivateCount++;
- for (i = 0; i < xf86NumEntities; i++) {
- pEnt = xf86Entities[i];
- nprivs = xnfrealloc(pEnt->entityPrivates,
- xf86EntityPrivateCount * sizeof(DevUnion));
- /* Zero the new private */
- bzero(&nprivs[idx], sizeof(DevUnion));
- pEnt->entityPrivates = nprivs;
- }
- return idx;
-}
-
-DevUnion *
-xf86GetEntityPrivate(int entityIndex, int privIndex)
-{
- if (entityIndex >= xf86NumEntities || privIndex >= xf86EntityPrivateCount)
- return NULL;
-
- return &(xf86Entities[entityIndex]->entityPrivates[privIndex]);
-}
-