Attachment #95367 for bug #197572

View | Details | Raw Unified | Return to bug 197572
Collapse All | Expand All

Lines 155-160 void xf86AddDevToEntity(int entityIndex, Link Here

(-)programs/Xserver/hw/xfree86/common/xf86Priv.h (+1 lines)
155	extern void xf86PostPreInit(void);	155	extern void xf86PostPreInit(void);
156	extern void xf86PostScreenInit(void);	156	extern void xf86PostScreenInit(void);
157	extern memType getValidBIOSBase(PCITAG tag, int num);	157	extern memType getValidBIOSBase(PCITAG tag, int num);
		158	extern memType getEmptyPciRange(PCITAG tag, int base_reg);
158	extern int pciTestMultiDeviceCard(int bus, int dev, int func, PCITAG** pTag);	159	extern int pciTestMultiDeviceCard(int bus, int dev, int func, PCITAG** pTag);
159		160
160	/* xf86Config.c */	161	/* xf86Config.c */




/*
 * BIOS releated
 */
static resPtr
getOwnResources(pciVideoPtr pvp, resPtr mem)
{
    resRange range;
    int i;
    /* Make sure we don't conflict with our own mem resources */
    for (i = 0; i < 6; i++) {
	if (!pvp->memBase[i])
	    continue;
	P_M_RANGE(range,TAG(pvp),pvp->memBase[i],pvp->size[i],
		  ResExcMemBlock);
	mem = xf86AddResToList(mem,&range,-1);
    }
    return mem;
}

static void
getPciRangesForMapping(pciVideoPtr pvp,  resPtr *map, resPtr *avoid)
{
    pciVideoPtr pvp = NULL;
    PciBusPtr pbp;
    resPtr tmp;
    
    *avoid = xf86DupResList(pciAvoidRes);

    pbp = xf86PciBus;
    while (pbp) {
	if (pbp->secondary == pvp->bus) {
	    if (pbp->preferred_pmem)
		tmp = xf86DupResList(pbp->preferred_pmem);
	    else
		tmp = xf86DupResList(pbp->pmem);
	    *map = xf86JoinResLists(*map,tmp);
	    if (pbp->preferred_mem)
		tmp = xf86DupResList(pbp->preferred_mem);
	    else
		tmp = xf86DupResList(pbp->mem);
	    *map = xf86JoinResLists(*map,tmp);
	    tmp = *map;
	    while (tmp) {
		tmp->block_end = min(tmp->block_end,PCI_MEM32_LENGTH_MAX);
		tmp = tmp->next;
	    }
	} else if ((pbp->primary == pvp->bus) &&
		   (pbp->secondary >= 0) &&
		   (pbp->primary != pbp->secondary)) {
	    tmp = xf86DupResList(pbp->preferred_pmem);
	    *avoid = xf86JoinResLists(*avoid, tmp);
	    tmp = xf86DupResList(pbp->pmem);
	    *avoid = xf86JoinResLists(*avoid, tmp);
	    tmp = xf86DupResList(pbp->preferred_mem);
	    *avoid = xf86JoinResLists(*avoid, tmp);
	    tmp = xf86DupResList(pbp->mem);
	    *avoid = xf86JoinResLists(*avoid, tmp);
	}
	pbp = pbp->next;
    }	
    pciConvertListToHost(pvp->bus,pvp->device,pvp->func, *avoid);
    pciConvertListToHost(pvp->bus,pvp->device,pvp->func, *map);
}

static memType
findPciRange(PCITAG tag, resPtr m, resPtr avoid, CARD32 size)
{
    resRange range;
    CARD32 alignment = (1 << size) - 1;
    
    while (m) {
	range = xf86GetBlock(RANGE_TYPE(ResExcMemBlock, xf86GetPciDomain(tag)),
			     PCI_SIZE(ResMem, tag, 1 << size),
			     m->block_begin, m->block_end,
			     PCI_SIZE(ResMem, tag, alignment), 
			     avoid);
	if (range.type != ResEnd) {
	    return  M2B(tag, range.rBase);
	}
	m = m->next;
    }
    return 0;
}

pciVideoPtr
getPciVideoPtr(tag)
{
    int n = 0;
    int i;
    CARD32 biosSize, alignment;

    pciVideoPtr pvp = NULL;
    if (!xf86PciVideoInfo) return 0;
    
    while ((pvp = xf86PciVideoInfo[n++])) {
	if (pciTag(pvp->bus,pvp->device,pvp->func) == tag)
	    return pvp;
    }
    return NULL;
}

memType
getValidBIOSBase(PCITAG tag, int num)
{
    pciVideoPtr pvp = NULL;
    memType ret;
    CARD32 biosSize;
    resPtr mem = NULL;
    resPtr avoid = NULL, m = NULL;
    resRange range;
    
    pvp = getPciVideoPtr(tag);
    
    if (!pvp) return 0;

    biosSize = pvp->biosSize;

    if (biosSize > 24)
	biosSize = 24;


	/* In some cases the BIOS base register contains the size mask */
	if ((memType)(-1 << biosSize) == PCIGETROM(pvp->biosBase))
	    return 0;
	mem = getOwnResources(pvp,mem);
	P_M_RANGE(range, tag, pvp->biosBase,biosSize,ResExcMemBlock);
	    if (!pvp->memBase[i])
		continue;
	    P_M_RANGE(range,TAG(pvp),pvp->memBase[i],pvp->size[i],
		      ResExcMemBlock);
	    mem = xf86AddResToList(mem,&range,-1);
	}
	P_M_RANGE(range, TAG(pvp),pvp->biosBase,biosSize,ResExcMemBlock);
	ret = pvp->biosBase;
	break;
    case ROM_BASE_MEM0:

    case ROM_BASE_MEM5:
	if (!pvp->memBase[num] || (pvp->size[num] < biosSize))
	    return 0;
	P_M_RANGE(range, tag ,pvp->memBase[num],biosSize,
		  ResExcMemBlock);
	ret = pvp->memBase[num];
	break;

    }

    /* Now find the ranges for validation */
    getPciRangesForMapping(pvp,&m,&avoid);
    
    while (pbp) {
	if (pbp->secondary == pvp->bus) {
	    if (pbp->preferred_pmem)
		tmp = xf86DupResList(pbp->preferred_pmem);
	    else
		tmp = xf86DupResList(pbp->pmem);
	    m = xf86JoinResLists(m,tmp);
	    if (pbp->preferred_mem)
		tmp = xf86DupResList(pbp->preferred_mem);
	    else
		tmp = xf86DupResList(pbp->mem);
	    m = xf86JoinResLists(m,tmp);
	    tmp = m;
	    while (tmp) {
		tmp->block_end = min(tmp->block_end,PCI_MEM32_LENGTH_MAX);
		tmp = tmp->next;
	    }
	} else if ((pbp->primary == pvp->bus) &&
		   (pbp->secondary >= 0) &&
		   (pbp->primary != pbp->secondary)) {
	    tmp = xf86DupResList(pbp->preferred_pmem);
	    avoid = xf86JoinResLists(avoid, tmp);
	    tmp = xf86DupResList(pbp->pmem);
	    avoid = xf86JoinResLists(avoid, tmp);
	    tmp = xf86DupResList(pbp->preferred_mem);
	    avoid = xf86JoinResLists(avoid, tmp);
	    tmp = xf86DupResList(pbp->mem);
	    avoid = xf86JoinResLists(avoid, tmp);
	}
	pbp = pbp->next;
    }	
    pciConvertListToHost(pvp->bus,pvp->device,pvp->func, avoid);
    if (mem)
	pciConvertListToHost(pvp->bus,pvp->device,pvp->func, mem);

    if (!ret) {
	/* Return a possible window */
	ret = findPciRange(tag,m,avoid,biosSize);
	    range = xf86GetBlock(RANGE_TYPE(ResExcMemBlock, xf86GetPciDomain(tag)),
				 PCI_SIZE(ResMem, TAG(pvp), 1 << biosSize),
				 m->block_begin, m->block_end,
				 PCI_SIZE(ResMem, TAG(pvp), alignment), 
				 avoid);
	    if (range.type != ResEnd) {
		ret =  M2B(TAG(pvp), range.rBase);
		break;
	    }
	    m = m->next;
	}
    } else {
#if !defined(__ia64__) /* on ia64, trust the kernel, don't look for overlaps */
	if (mem)
	    pciConvertListToHost(pvp->bus,pvp->device,pvp->func, mem);
	if (!xf86IsSubsetOf(range, m) || 
	    ChkConflict(&range, avoid, SETUP) 
	    || (mem && ChkConflict(&range, mem, SETUP))) 

    return ret;
}

memType
getEmptyPciRange(PCITAG tag, int base_reg)
{
    resPtr avoid = NULL, m = NULL;
    memType ret;

    pciVideoPtr pvp = getPciVideoPtr(tag);
    if (!pvp) return 0;
    getPciRangesForMapping(pvp,&m,&avoid);
    ret = findPciRange(tag,m,avoid,pvp->size[base_reg]);
    xf86FreeResList(avoid);
    xf86FreeResList(m);

    return ret;
}

/*
 * xf86Bus.c interface
 */

Lines 8-13 INCLUDES = -I. -I$(XF86COMSRC) -I$(XF86O Link Here

(-)programs/Xserver/hw/xfree86/dummylib/Imakefile (+2 lines)
8	SRCS = \	8	SRCS = \
9	fatalerror.c \	9	fatalerror.c \
10	getvalidbios.c \	10	getvalidbios.c \
		11	getemptypci.c \
11	logvwrite.c \	12	logvwrite.c \
12	pcitestmulti.c \	13	pcitestmulti.c \
13	verrorf.c \	14	verrorf.c \
Lines 32-37 SRCS = \ Link Here
32	OBJS = \	33	OBJS = \
33	fatalerror.o \	34	fatalerror.o \
34	getvalidbios.o \	35	getvalidbios.o \
		36	getemptypci.o \
35	logvwrite.o \	37	logvwrite.o \
36	pcitestmulti.o \	38	pcitestmulti.o \
37	verrorf.o \	39	verrorf.o \





#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif

#include <X11/X.h>
#include "os.h"
#include "xf86.h"
#include "xf86Priv.h"

/*
 * Utility functions required by libxf86_os. 
 */

memType
getEmptyPciRange(PCITAG tag, int base_reg)
{
    return 0;
}




    return pci_devp;
}

pciConfigPtr
xf86GetPciConfigFromTag(PCITAG Tag)
{
    pciConfigPtr pDev;
    int i = 0;

    for (i = 0 ; (pDev = pci_devp[i]) && i <= MAX_PCI_DEVICES; i++) {
	if (Tag == pDev->tag)
	    return pDev;
    }

    return NULL;	/* Bad data */
}

CARD32
pciCheckForBrokenBase(PCITAG Tag,int basereg)
{


	/* if we use a mem base save it and move it out of the way */
	if (b_reg >= 0 && b_reg <= 5) {
	    memType emptybase;
	    savebase = pciReadLong(Tag, PCI_MAP_REG_START+(b_reg<<2));
	    xf86MsgVerb(X_INFO,5,"xf86ReadPciBios: modifying membase[%i]"
			" for device %i:%i:%i\n", basereg,
			(int)PCI_BUS_FROM_TAG(Tag), (int)PCI_DEV_FROM_TAG(Tag),
			(int)PCI_FUNC_FROM_TAG(Tag));
	    if (!(emptybase = getEmptyPciRange(Tag,b_reg))) {
		xf86Msg(X_ERROR,"Cannot find empty range to map base to\n");
		return 0;
	    }
	    pciWriteLong(Tag, PCI_MAP_REG_START + (b_reg << 2),
			 emptybase);
	}
	/* Set ROM base address and enable ROM address decoding */
	pciWriteLong(Tag, PCI_MAP_ROM_REG, romaddr

Lines 780-785 int xf86ReadPciBIOSByType(unsigned Link Here

(-)programs/Xserver/hw/xfree86/os-support/bus/xf86Pci.h (+1 lines)
780	int xf86GetAvailablePciBIOSTypes(PCITAG Tag, int basereg,	780	int xf86GetAvailablePciBIOSTypes(PCITAG Tag, int basereg,
781	PciBiosType *Buf);	781	PciBiosType *Buf);
782	pciConfigPtr *xf86scanpci(int flags);	782	pciConfigPtr *xf86scanpci(int flags);
		783	pciConfigPtr xf86GetPciConfigFromTag(PCITAG Tag);
783		784
784	extern int pciNumBuses;	785	extern int pciNumBuses;
785		786

Lines 201-206 xf86GetOSOffsetFromPCI(PCITAG tag, int s Link Here

(-)programs/Xserver/hw/xfree86/os-support/linux/lnx_pci.c (-4 / +4 lines)
201	fn = devfn & 0x7;	201	fn = devfn & 0x7;
202	if (tag == pciTag(bus,dev,fn)) {	202	if (tag == pciTag(bus,dev,fn)) {
203	/* ok now look through all the BAR values of this device */	203	/* ok now look through all the BAR values of this device */
		204	pciConfigPtr pDev = xf86GetPciConfigFromTag(tag);
		205
204	for (ndx=0; ndx<7; ndx++) {	206	for (ndx=0; ndx<7; ndx++) {
205	unsigned long savePtr;	207	unsigned long savePtr;
206	/*	208	/*
Lines 208-218 xf86GetOSOffsetFromPCI(PCITAG tag, int s Link Here
208	* memory attributes	210	* memory attributes
209	*/	211	*/
210	if (ndx == 6)	212	if (ndx == 6)
211	savePtr = (0xFFFFFFF0) &	213	savePtr = PCIGETROM(pDev->pci_baserom);
212	pciReadLong(tag, PCI_CMD_BIOS_REG);
213	else /* this the ROM bar */	214	else /* this the ROM bar */
214	savePtr = (0xFFFFFFF0) &	215	savePtr = (0xFFFFFFF0) & (&pDev->pci_base0)[ndx];
215	pciReadLong(tag, PCI_CMD_BASE_REG + (0x4 * ndx));
216		216
217	/* find the index of the incoming base */	217	/* find the index of the incoming base */
218	if (base >= savePtr && base <= (savePtr + size[ndx])) {	218	if (base >= savePtr && base <= (savePtr + size[ndx])) {

Return to bug 197572

Lines 1068-1073 xf86scanpci(int flags) Link Here

(-)programs/Xserver/hw/xfree86/os-support/bus/Pci.c (-1 / +20 lines)
1068	return pci_devp;	1068	return pci_devp;
1069	}	1069	}
1070		1070
		1071	pciConfigPtr
		1072	xf86GetPciConfigFromTag(PCITAG Tag)
		1073	{
		1074	pciConfigPtr pDev;
		1075	int i = 0;
		1076
		1077	for (i = 0 ; (pDev = pci_devp[i]) && i <= MAX_PCI_DEVICES; i++) {
		1078	if (Tag == pDev->tag)
		1079	return pDev;
		1080	}
		1081
		1082	return NULL; /* Bad data */
		1083	}
		1084
1071	CARD32	1085	CARD32
1072	pciCheckForBrokenBase(PCITAG Tag,int basereg)	1086	pciCheckForBrokenBase(PCITAG Tag,int basereg)
1073	{	1087	{
Lines 1160-1172 handlePciBIOS(PCITAG Tag, int basereg, Link Here
1160		1174
1161	/* if we use a mem base save it and move it out of the way */	1175	/* if we use a mem base save it and move it out of the way */
1162	if (b_reg >= 0 && b_reg <= 5) {	1176	if (b_reg >= 0 && b_reg <= 5) {
		1177	memType emptybase;
1163	savebase = pciReadLong(Tag, PCI_MAP_REG_START+(b_reg<<2));	1178	savebase = pciReadLong(Tag, PCI_MAP_REG_START+(b_reg<<2));
1164	xf86MsgVerb(X_INFO,5,"xf86ReadPciBios: modifying membase[%i]"	1179	xf86MsgVerb(X_INFO,5,"xf86ReadPciBios: modifying membase[%i]"
1165	" for device %i:%i:%i\n", basereg,	1180	" for device %i:%i:%i\n", basereg,
1166	(int)PCI_BUS_FROM_TAG(Tag), (int)PCI_DEV_FROM_TAG(Tag),	1181	(int)PCI_BUS_FROM_TAG(Tag), (int)PCI_DEV_FROM_TAG(Tag),
1167	(int)PCI_FUNC_FROM_TAG(Tag));	1182	(int)PCI_FUNC_FROM_TAG(Tag));
		1183	if (!(emptybase = getEmptyPciRange(Tag,b_reg))) {
		1184	xf86Msg(X_ERROR,"Cannot find empty range to map base to\n");
		1185	return 0;
		1186	}
1168	pciWriteLong(Tag, PCI_MAP_REG_START + (b_reg << 2),	1187	pciWriteLong(Tag, PCI_MAP_REG_START + (b_reg << 2),
1169	(CARD32)~0);	1188	emptybase);
1170	}	1189	}
1171	/* Set ROM base address and enable ROM address decoding */	1190	/* Set ROM base address and enable ROM address decoding */
1172	pciWriteLong(Tag, PCI_MAP_ROM_REG, romaddr	1191	pciWriteLong(Tag, PCI_MAP_ROM_REG, romaddr

Lines 1516-1544 xf86ReallocatePciResources(int entityInd Link Here

(-)programs/Xserver/hw/xfree86/common/xf86pciBus.c (-69 / +122 lines)
1516	/*	1516	/*
1517	* BIOS releated	1517	* BIOS releated
1518	*/	1518	*/
1519	memType	1519	static resPtr
1520	getValidBIOSBase(PCITAG tag, int num)	1520	getOwnResources(pciVideoPtr pvp, resPtr mem)
		1521	{
		1522	resRange range;
		1523	int i;
		1524	/* Make sure we don't conflict with our own mem resources */
		1525	for (i = 0; i < 6; i++) {
		1526	if (!pvp->memBase[i])
		1527	continue;
		1528	P_M_RANGE(range,TAG(pvp),pvp->memBase[i],pvp->size[i],
		1529	ResExcMemBlock);
		1530	mem = xf86AddResToList(mem,&range,-1);
		1531	}
		1532	return mem;
		1533	}
		1534
		1535	static void
		1536	getPciRangesForMapping(pciVideoPtr pvp, resPtr map, resPtr avoid)
1521	{	1537	{
1522	pciVideoPtr pvp = NULL;
1523	PciBusPtr pbp;	1538	PciBusPtr pbp;
1524	resPtr m = NULL;	1539	resPtr tmp;
1525	resPtr tmp, avoid, mem = NULL;	1540
		1541	*avoid = xf86DupResList(pciAvoidRes);
		1542
		1543	pbp = xf86PciBus;
		1544	while (pbp) {
		1545	if (pbp->secondary == pvp->bus) {
		1546	if (pbp->preferred_pmem)
		1547	tmp = xf86DupResList(pbp->preferred_pmem);
		1548	else
		1549	tmp = xf86DupResList(pbp->pmem);
		1550	map = xf86JoinResLists(map,tmp);
		1551	if (pbp->preferred_mem)
		1552	tmp = xf86DupResList(pbp->preferred_mem);
		1553	else
		1554	tmp = xf86DupResList(pbp->mem);
		1555	map = xf86JoinResLists(map,tmp);
		1556	tmp = *map;
		1557	while (tmp) {
		1558	tmp->block_end = min(tmp->block_end,PCI_MEM32_LENGTH_MAX);
		1559	tmp = tmp->next;
		1560	}
		1561	} else if ((pbp->primary == pvp->bus) &&
		1562	(pbp->secondary >= 0) &&
		1563	(pbp->primary != pbp->secondary)) {
		1564	tmp = xf86DupResList(pbp->preferred_pmem);
		1565	avoid = xf86JoinResLists(avoid, tmp);
		1566	tmp = xf86DupResList(pbp->pmem);
		1567	avoid = xf86JoinResLists(avoid, tmp);
		1568	tmp = xf86DupResList(pbp->preferred_mem);
		1569	avoid = xf86JoinResLists(avoid, tmp);
		1570	tmp = xf86DupResList(pbp->mem);
		1571	avoid = xf86JoinResLists(avoid, tmp);
		1572	}
		1573	pbp = pbp->next;
		1574	}
		1575	pciConvertListToHost(pvp->bus,pvp->device,pvp->func, *avoid);
		1576	pciConvertListToHost(pvp->bus,pvp->device,pvp->func, *map);
		1577	}
		1578
		1579	static memType
		1580	findPciRange(PCITAG tag, resPtr m, resPtr avoid, CARD32 size)
		1581	{
1526	resRange range;	1582	resRange range;
1527	memType ret;	1583	CARD32 alignment = (1 << size) - 1;
		1584
		1585	while (m) {
		1586	range = xf86GetBlock(RANGE_TYPE(ResExcMemBlock, xf86GetPciDomain(tag)),
		1587	PCI_SIZE(ResMem, tag, 1 << size),
		1588	m->block_begin, m->block_end,
		1589	PCI_SIZE(ResMem, tag, alignment),
		1590	avoid);
		1591	if (range.type != ResEnd) {
		1592	return M2B(tag, range.rBase);
		1593	}
		1594	m = m->next;
		1595	}
		1596	return 0;
		1597	}
		1598
		1599	pciVideoPtr
		1600	getPciVideoPtr(tag)
		1601	{
1528	int n = 0;	1602	int n = 0;
1529	int i;
1530	CARD32 biosSize, alignment;
1531		1603
		1604	pciVideoPtr pvp = NULL;
1532	if (!xf86PciVideoInfo) return 0;	1605	if (!xf86PciVideoInfo) return 0;
1533		1606
1534	while ((pvp = xf86PciVideoInfo[n++])) {	1607	while ((pvp = xf86PciVideoInfo[n++])) {
1535	if (pciTag(pvp->bus,pvp->device,pvp->func) == tag)	1608	if (pciTag(pvp->bus,pvp->device,pvp->func) == tag)
1536	break;	1609	return pvp;
1537	}	1610	}
		1611	return NULL;
		1612	}
		1613
		1614	memType
		1615	getValidBIOSBase(PCITAG tag, int num)
		1616	{
		1617	pciVideoPtr pvp = NULL;
		1618	memType ret;
		1619	CARD32 biosSize;
		1620	resPtr mem = NULL;
		1621	resPtr avoid = NULL, m = NULL;
		1622	resRange range;
		1623
		1624	pvp = getPciVideoPtr(tag);
		1625
1538	if (!pvp) return 0;	1626	if (!pvp) return 0;
1539		1627
1540	biosSize = pvp->biosSize;	1628	biosSize = pvp->biosSize;
1541	alignment = (1 << biosSize) - 1;	1629
1542	if (biosSize > 24)	1630	if (biosSize > 24)
1543	biosSize = 24;	1631	biosSize = 24;
1544		1632
Lines 1549-1563 getValidBIOSBase(PCITAG tag, int num) Link Here
1549	/* In some cases the BIOS base register contains the size mask */	1637	/* In some cases the BIOS base register contains the size mask */
1550	if ((memType)(-1 << biosSize) == PCIGETROM(pvp->biosBase))	1638	if ((memType)(-1 << biosSize) == PCIGETROM(pvp->biosBase))
1551	return 0;	1639	return 0;
1552	/* Make sure we don't conflict with our own mem resources */	1640	mem = getOwnResources(pvp,mem);
1553	for (i = 0; i < 6; i++) {	1641	P_M_RANGE(range, tag, pvp->biosBase,biosSize,ResExcMemBlock);
1554	if (!pvp->memBase[i])
1555	continue;
1556	P_M_RANGE(range,TAG(pvp),pvp->memBase[i],pvp->size[i],
1557	ResExcMemBlock);
1558	mem = xf86AddResToList(mem,&range,-1);
1559	}
1560	P_M_RANGE(range, TAG(pvp),pvp->biosBase,biosSize,ResExcMemBlock);
1561	ret = pvp->biosBase;	1642	ret = pvp->biosBase;
1562	break;	1643	break;
1563	case ROM_BASE_MEM0:	1644	case ROM_BASE_MEM0:
Lines 1568-1574 getValidBIOSBase(PCITAG tag, int num) Link Here
1568	case ROM_BASE_MEM5:	1649	case ROM_BASE_MEM5:
1569	if (!pvp->memBase[num] \|\| (pvp->size[num] < biosSize))	1650	if (!pvp->memBase[num] \|\| (pvp->size[num] < biosSize))
1570	return 0;	1651	return 0;
1571	P_M_RANGE(range, TAG(pvp),pvp->memBase[num],biosSize,	1652	P_M_RANGE(range, tag ,pvp->memBase[num],biosSize,
1572	ResExcMemBlock);	1653	ResExcMemBlock);
1573	ret = pvp->memBase[num];	1654	ret = pvp->memBase[num];
1574	break;	1655	break;
Lines 1580-1638 getValidBIOSBase(PCITAG tag, int num) Link Here
1580	}	1661	}
1581		1662
1582	/* Now find the ranges for validation */	1663	/* Now find the ranges for validation */
1583	avoid = xf86DupResList(pciAvoidRes);	1664	getPciRangesForMapping(pvp,&m,&avoid);
1584	pbp = xf86PciBus;	1665
1585	while (pbp) {
1586	if (pbp->secondary == pvp->bus) {
1587	if (pbp->preferred_pmem)
1588	tmp = xf86DupResList(pbp->preferred_pmem);
1589	else
1590	tmp = xf86DupResList(pbp->pmem);
1591	m = xf86JoinResLists(m,tmp);
1592	if (pbp->preferred_mem)
1593	tmp = xf86DupResList(pbp->preferred_mem);
1594	else
1595	tmp = xf86DupResList(pbp->mem);
1596	m = xf86JoinResLists(m,tmp);
1597	tmp = m;
1598	while (tmp) {
1599	tmp->block_end = min(tmp->block_end,PCI_MEM32_LENGTH_MAX);
1600	tmp = tmp->next;
1601	}
1602	} else if ((pbp->primary == pvp->bus) &&
1603	(pbp->secondary >= 0) &&
1604	(pbp->primary != pbp->secondary)) {
1605	tmp = xf86DupResList(pbp->preferred_pmem);
1606	avoid = xf86JoinResLists(avoid, tmp);
1607	tmp = xf86DupResList(pbp->pmem);
1608	avoid = xf86JoinResLists(avoid, tmp);
1609	tmp = xf86DupResList(pbp->preferred_mem);
1610	avoid = xf86JoinResLists(avoid, tmp);
1611	tmp = xf86DupResList(pbp->mem);
1612	avoid = xf86JoinResLists(avoid, tmp);
1613	}
1614	pbp = pbp->next;
1615	}
1616	pciConvertListToHost(pvp->bus,pvp->device,pvp->func, avoid);
1617	if (mem)
1618	pciConvertListToHost(pvp->bus,pvp->device,pvp->func, mem);
1619
1620	if (!ret) {	1666	if (!ret) {
1621	/* Return a possible window */	1667	/* Return a possible window */
1622	while (m) {	1668	ret = findPciRange(tag,m,avoid,biosSize);
1623	range = xf86GetBlock(RANGE_TYPE(ResExcMemBlock, xf86GetPciDomain(tag)),
1624	PCI_SIZE(ResMem, TAG(pvp), 1 << biosSize),
1625	m->block_begin, m->block_end,
1626	PCI_SIZE(ResMem, TAG(pvp), alignment),
1627	avoid);
1628	if (range.type != ResEnd) {
1629	ret = M2B(TAG(pvp), range.rBase);
1630	break;
1631	}
1632	m = m->next;
1633	}
1634	} else {	1669	} else {
1635	#if !defined(__ia64__) /* on ia64, trust the kernel, don't look for overlaps */	1670	#if !defined(__ia64__) /* on ia64, trust the kernel, don't look for overlaps */
		1671	if (mem)
		1672	pciConvertListToHost(pvp->bus,pvp->device,pvp->func, mem);
1636	if (!xf86IsSubsetOf(range, m) \|\|	1673	if (!xf86IsSubsetOf(range, m) \|\|
1637	ChkConflict(&range, avoid, SETUP)	1674	ChkConflict(&range, avoid, SETUP)
1638	\|\| (mem && ChkConflict(&range, mem, SETUP)))	1675	\|\| (mem && ChkConflict(&range, mem, SETUP)))
Lines 1645-1650 getValidBIOSBase(PCITAG tag, int num) Link Here
1645	return ret;	1682	return ret;
1646	}	1683	}
1647		1684
		1685	memType
		1686	getEmptyPciRange(PCITAG tag, int base_reg)
		1687	{
		1688	resPtr avoid = NULL, m = NULL;
		1689	memType ret;
		1690
		1691	pciVideoPtr pvp = getPciVideoPtr(tag);
		1692	if (!pvp) return 0;
		1693	getPciRangesForMapping(pvp,&m,&avoid);
		1694	ret = findPciRange(tag,m,avoid,pvp->size[base_reg]);
		1695	xf86FreeResList(avoid);
		1696	xf86FreeResList(m);
		1697
		1698	return ret;
		1699	}
		1700
1648	/*	1701	/*
1649	* xf86Bus.c interface	1702	* xf86Bus.c interface
1650	*/	1703	*/

Added Link Here

(-)programs/Xserver/hw/xfree86/dummylib/getemptypci.c (+19 lines)
1
2	#ifdef HAVE_XORG_CONFIG_H
3	#include <xorg-config.h>
4	#endif
5
6	#include <X11/X.h>
7	#include "os.h"
8	#include "xf86.h"
9	#include "xf86Priv.h"
10
11	/*
12	* Utility functions required by libxf86_os.
13	*/
14
15	memType
16	getEmptyPciRange(PCITAG tag, int base_reg)
17	{
18	return 0;
19	}