Attachment #58776 for bug #132308

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




  return bits;
}

void
pciInfoFromTag(PCITAG tag, int *domainnum, int *busnum,
               int *devnum, int *funcnum)
{
    *domainnum = PCI_DOM_FROM_TAG(tag);
    *busnum = PCI_BUS_NO_DOMAIN(PCI_BUS_FROM_TAG(tag));
    *devnum = PCI_DEV_FROM_TAG(tag);
    *funcnum = PCI_FUNC_FROM_TAG(tag);
}

PCITAG
pciTag(int busnum, int devnum, int funcnum)
{

Lines 120-126 Link Here

(-)xc.orig/programs/Xserver/hw/xfree86/os-support/bus/Pci.h (-2 / +2 lines)
120	/* by xf86scanpci */	120	/* by xf86scanpci */
121	#if defined(sun) && defined(SVR4) && defined(sparc)	121	#if defined(sun) && defined(SVR4) && defined(sparc)
122	# define MAX_PCI_BUSES 4096 /* Max number of PCI buses */	122	# define MAX_PCI_BUSES 4096 /* Max number of PCI buses */
123	#elif defined(__alpha__) && defined (linux)	123	#elif (defined(__alpha__) \|\| defined(__ia64__)) && defined (linux)
124	# define MAX_PCI_DOMAINS 512	124	# define MAX_PCI_DOMAINS 512
125	# define PCI_DOM_MASK 0x01fful	125	# define PCI_DOM_MASK 0x01fful
126	# define MAX_PCI_BUSES (MAX_PCI_DOMAINS256) / 256 per domain */	126	# define MAX_PCI_BUSES (MAX_PCI_DOMAINS256) / 256 per domain */
Lines 259-265 Link Here
259	# endif	259	# endif
260	#elif defined(__ia64__)	260	#elif defined(__ia64__)
261	# if defined(linux)	261	# if defined(linux)
262	# define ARCH_PCI_INIT linuxPciInit	262	# define ARCH_PCI_INIT ia64linuxPciInit
263	# define INCLUDE_XF86_MAP_PCI_MEM	263	# define INCLUDE_XF86_MAP_PCI_MEM
264	# elif defined(FreeBSD)	264	# elif defined(FreeBSD)
265	# define ARCH_PCI_INIT freebsdPciInit	265	# define ARCH_PCI_INIT freebsdPciInit




static void get_bridge_info(pciBusInfo_t *bus_info, pciDevice *pdev)
{
	unsigned int parent_segnum, segnum = PCI_DOM_FROM_TAG(pdev->tag);
	unsigned int parent_busnum, parent_nodombus, busnum = pdev->busnum;
	unsigned int nodombus = PCI_BUS_NO_DOMAIN(PCI_BUS_FROM_TAG(pdev->tag));
	char bridge_path[] = "/sys/class/pci_bus/0000:00/bridge";
	char bridge_target[] = "../../../devices/pci0000:00";

	/* Path to this device's bridge */
	sprintf(bridge_path, "/sys/class/pci_bus/%04x:%02x/bridge", segnum,
		nodombus);

	if (readlink(bridge_path, bridge_target, strlen(bridge_target)) < 0) {
		perror("failed to dereference bridge link");

	}

	sscanf(bridge_target, "../../../devices/pci%04x:%02x", &parent_segnum,
	       &parent_nodombus);

	parent_busnum = PCI_MAKE_BUS(parent_segnum, parent_nodombus);

	/*
	 * If there's no bridge or the bridge points to the device, use




#include "xf86Priv.h"
#include "xf86_OSlib.h"
#include "Pci.h"
#include <dirent.h>

/*
 * linux platform specific PCI access functions -- using /proc/bus/pci

static int
linuxPciOpenFile(PCITAG tag, Bool write)
{
	static int	ldomain, lbus,ldev,lfunc,fd = -1,is_write = 0;
	int		domain, bus, dev, func;
	char		file[32];
	struct stat	ignored;

	domain = PCI_DOM_FROM_TAG(tag);
	bus  = PCI_BUS_NO_DOMAIN(PCI_BUS_FROM_TAG(tag));
	dev  = PCI_DEV_FROM_TAG(tag);
	func = PCI_FUNC_FROM_TAG(tag);

	if (fd == -1 || (write && (!is_write)) || bus != lbus
		|| dev != ldev || func != lfunc || domain != ldomain) {

		if (fd != -1)
			close(fd);
		if (bus < 256) {
		        sprintf(file, "/proc/bus/pci/%04x:%02x", domain, bus);
			if (stat(file, &ignored) < 0) {
				if (domain == 0)
					sprintf(file, "/proc/bus/pci/%02x/%02x.%1x",
						bus, dev, func);
				else goto bail;
			} else
				sprintf(file, "/proc/bus/pci/%04x:%02x/%02x.%1x",
					domain, bus, dev, func);
		} else {
		        sprintf(file, "/proc/bus/pci/%04x:%04x", domain, bus);
			if (stat(file, &ignored) < 0) {
				if (domain == 0)
					sprintf(file, "/proc/bus/pci/%04x/%04x.%1x",
						bus, dev, func);
				else goto bail;
			} else
				sprintf(file, "/proc/bus/pci/%04x:%04x/%02x.%1x",
					domain, bus, dev, func);
		}
		if (write) {
			fd = open(file,O_RDWR);
			if (fd != -1) is_write = TRUE;
		} else switch (is_write) {
			case TRUE:
			    fd = open(file,O_RDWR);

			    fd = open(file,O_RDONLY);
			    is_write = FALSE;
		}
	bail:
		ldomain = domain;
		lbus  = bus;
		ldev  = dev;
		lfunc = func;

    pPCI = xf86GetPciHostConfigFromTag(Tag);

    if (pPCI && (result = PCI_DOM_FROM_BUS(pPCI->busnum)))
	return result + 1;

    if (!pPCI || pPCI->fakeDevice)
	return 1;		/* Domain 0 is reserved */

    struct stat st;

    dom  = PCI_DOM_FROM_TAG(Tag);
    bus  = PCI_BUS_NO_DOMAIN(PCI_BUS_FROM_TAG(Tag));
    dev  = PCI_DEV_FROM_TAG(Tag);
    func = PCI_FUNC_FROM_TAG(Tag);
    sprintf(file, "/sys/devices/pci%04x:%02x/%04x:%02x:%02x.%1x/rom",

}

#endif /* !INCLUDE_XF86_NO_DOMAIN */

#ifdef __ia64__
static PCITAG ia64linuxPciFindFirst(void);
static PCITAG ia64linuxPciFindNext(void);


void
ia64linuxPciInit()
{
    struct stat st;
    /* Be a little paranoid here and only use this code for Altix systems.
     * It is generic, so it should work on any system, but depends on
     * /proc/bus/pci entries for each domain/bus combination. Altix is
     * guaranteed a recent enough kernel to have them.
     */
    if (stat("/proc/sgi_sn/licenseID", &st)) {
	return linuxPciInit();
    }
    if ((xf86Info.pciFlags == PCIForceNone) ||
        (-1 == stat("/proc/bus/pci", &st))) {
             /* when using this as default for all linux architectures,
		   we'll need a fallback for 2.0 kernels here */
            return;
    }
    pciNumBuses    = 1;
    pciBusInfo[0]  = &linuxPci0;
    pciFindFirstFP = ia64linuxPciFindFirst;
    pciFindNextFP  = ia64linuxPciFindNext;
}

static DIR *busdomdir;
static DIR *devdir;

static PCITAG
ia64linuxPciFindFirst(void)
{
	busdomdir = opendir("/proc/bus/pci");
	devdir = NULL;

	return ia64linuxPciFindNext();
}

static struct dirent *getnextbus(int *domain, int *bus)
{
    struct dirent *entry;
    int dombus;

    for (;;) {
        entry = readdir(busdomdir);
        if (entry == NULL) {
            *domain = 0;
            *bus = 0;
            closedir(busdomdir);
            return NULL;
        }
        if (sscanf(entry->d_name, "%04x:%02x", domain, bus) != 2)
            continue;
        dombus = PCI_MAKE_BUS(*domain, *bus);

        if (pciNumBuses <= dombus)
            pciNumBuses = dombus + 1;
        if (!pciBusInfo[dombus]) {
            pciBusInfo[dombus] = xnfalloc(sizeof(pciBusInfo_t));
            *pciBusInfo[dombus] = *pciBusInfo[0];
        }

        return entry;
    }
}

static PCITAG
ia64linuxPciFindNext(void)
{
    struct dirent *entry;
    char file[40];
    static int bus, dev, func, domain;
    PCITAG pciDeviceTag;
    CARD32 devid;

    for (;;) {
        if (devdir == NULL) {
            entry = getnextbus(&domain, &bus);
            if (!entry)
                return PCI_NOT_FOUND;
            snprintf(file, 40, "/proc/bus/pci/%s", entry->d_name);
            devdir = opendir(file);
            if (!devdir)
                return PCI_NOT_FOUND;

        }

        entry = readdir(devdir);

        if (entry == NULL) {
            closedir(devdir);
            devdir = NULL;
            continue;
        }

        if (sscanf(entry->d_name, "%02x . %01x", &dev, &func) == 2) {
            pciDeviceTag = PCI_MAKE_TAG(PCI_MAKE_BUS(domain, bus), dev, func);
            devid = pciReadLong(pciDeviceTag, PCI_ID_REG);
            if ((devid & pciDevidMask) == pciDevid)
                /* Yes - Return it.  Otherwise, next device */
                return pciDeviceTag;
        }
    }
}
#endif

Lines 768-773 void pciSetBitsByte(PCITAG tag, in Link Here

(-)xc.orig/programs/Xserver/hw/xfree86/os-support/bus/xf86Pci.h (+2 lines)
768	ADDRESS pciBusAddrToHostAddr(PCITAG tag, PciAddrType type, ADDRESS addr);	768	ADDRESS pciBusAddrToHostAddr(PCITAG tag, PciAddrType type, ADDRESS addr);
769	ADDRESS pciHostAddrToBusAddr(PCITAG tag, PciAddrType type, ADDRESS addr);	769	ADDRESS pciHostAddrToBusAddr(PCITAG tag, PciAddrType type, ADDRESS addr);
770	PCITAG pciTag(int busnum, int devnum, int funcnum);	770	PCITAG pciTag(int busnum, int devnum, int funcnum);
		771	void pciInfoFromTag(PCITAG tag, int *domainnum,
		772	int busnum, int devnum, int *funcnum);
771	int pciGetBaseSize(PCITAG tag, int indx, Bool destructive, Bool *min);	773	int pciGetBaseSize(PCITAG tag, int indx, Bool destructive, Bool *min);
772	CARD32 pciCheckForBrokenBase(PCITAG tag,int basereg);	774	CARD32 pciCheckForBrokenBase(PCITAG tag,int basereg);
773	pointer xf86MapPciMem(int ScreenNum, int Flags, PCITAG Tag,	775	pointer xf86MapPciMem(int ScreenNum, int Flags, PCITAG Tag,

Lines 478-484 pciCfg1in(CARD16 addr, CARD32 *val) Link Here

(-)xc.orig/programs/Xserver/hw/xfree86/int10/helper_exec.c (-2 / +2 lines)
478	return 1;	478	return 1;
479	}	479	}
480	if (addr == 0xCFC) {	480	if (addr == 0xCFC) {
481	*val = pciReadLong(TAG(PciCfg1Addr), OFFSET(PciCfg1Addr));	481	*val = pciReadLong(Int10Current->Tag, OFFSET(PciCfg1Addr));
482	return 1;	482	return 1;
483	}	483	}
484	return 0;	484	return 0;
Lines 492-498 pciCfg1out(CARD16 addr, CARD32 val) Link Here
492	return 1;	492	return 1;
493	}	493	}
494	if (addr == 0xCFC) {	494	if (addr == 0xCFC) {
495	pciWriteLong(TAG(PciCfg1Addr), OFFSET(PciCfg1Addr), val);	495	pciWriteLong(Int10Current->Tag, OFFSET(PciCfg1Addr),val);
496	return 1;	496	return 1;
497	}	497	}
498	return 0;	498	return 0;




Bool
xf86GetPciSizeFromOS(PCITAG tag, int index, int* bits)
{
    FILE *file;
    char c[0x200];
    char *res;
    unsigned int domain, bus, devfn, dev, fn;
    unsigned PCIADDR_TYPE size[7];
    unsigned int num;
    signed PCIADDR_TYPE Size;
    int resource;
    unsigned PCIADDR_TYPE begin, end;

    if (index > 7)
	return FALSE;

    pciInfoFromTag(tag, &domain, &bus, &dev, &fn);

    sprintf(c, "/sys/devices/pci%04x:%02x/%04x:%02x:%02x.%1x/resource",
	    domain, bus, domain, bus, dev, fn);
    if (file = fopen(c, "r")) {
        for (resource=0; resource != index; resource++)
            fgets(c, 0x1ff, file);
        res = fgets(c, 0x1ff, file);
        num = sscanf(res, PCIADDR_FMT " " PCIADDR_FMT " " PCIADDR_IGNORE_FMT,
                     &begin, &end);
        if (num == 2) {
            Size = end - begin;
		    while (Size & ((PCIADDR_TYPE) 0x01)) {
                Size = Size >> ((PCIADDR_TYPE) 1);
                (*bits)++;
            }
            fclose(file);
            return TRUE;
        }
        fclose(file);
    }

    if (!xf86OSLinuxPCIFile && \
        !(xf86OSLinuxPCIFile = fopen("/proc/bus/pci/devices","r")))
	return FALSE;

    FILE *file;
    char c[0x200];
    char *res;
    unsigned int domain, bus, devfn, dev, fn;
    unsigned PCIADDR_TYPE offset[7];
    unsigned int num;
    int resource;

    if (index > 7)
        return FALSE;

    pciInfoFromTag(tag, &domain, &bus, &dev, &fn);

    sprintf(c, "/sys/devices/pci%04x:%02x/%04x:%02x:%02x.%1x/resource",
	    domain, bus, domain, bus, dev, fn);
    if (file = fopen(c, "r")) {
        for (resource=0; resource != index; resource++)
            fgets(c, 0x1ff, file);
        res = fgets(c, 0x1ff, file);
        num = sscanf(res, PCIADDR_FMT " " PCIADDR_IGNORE_FMT " " PCIADDR_IGNORE_FMT,
                     &offset[0]);
        if (num == 1) {
            *bases = offset[0];
            fclose(file);
            return TRUE;
        }
        fclose(file);
    }

    if (!(file = fopen("/proc/bus/pci/devices","r")))
        return FALSE;
    do {

    FILE *file;
    char c[0x200];
    char *res;
    unsigned int domain, bus, devfn, dev, fn;
    unsigned PCIADDR_TYPE offset[7];
    unsigned PCIADDR_TYPE size[7];
    unsigned int num;
    unsigned int ndx;
    unsigned PCIADDR_TYPE begin,end;

    pciInfoFromTag(tag, &domain, &bus, &dev, &fn);

    sprintf(c, "/sys/devices/pci%04x:%02x/%04x:%02x:%02x.%1x/resource",
	    domain, bus, domain, bus, dev, fn);
    if (file = fopen(c, "r")) {
        unsigned long savePtr;
        for (ndx=0; ndx < 7; ndx++) {
            res = fgets(c, 0x1ff, file);
            if (!res)
                break;
            num = sscanf(res, PCIADDR_FMT " " PCIADDR_FMT " " PCIADDR_IGNORE_FMT,
                         &begin, &end);
            if (num == 2) {
                if (ndx == 6)
                    savePtr = (0xFFFFFFF0) &
                        pciReadLong(tag, PCI_CMD_BIOS_REG);
                else /* this the ROM bar */
                    savePtr = (0xFFFFFFF0) &
                        pciReadLong(tag, PCI_CMD_BASE_REG + (0x4 * ndx));
                if (base >= savePtr && base <= (savePtr + (end - begin))) {
                    fclose(file);
                    return ( ~(0xFUL) & (begin + (base - savePtr)));
                }
            }
        }
        fclose(file);
    }

    if (!(file = fopen("/proc/bus/pci/devices","r")))
        return 0;

Return to bug 132308

Lines 597-602 pciGetBaseSize(PCITAG tag, int index, Bo Link Here

(-)xc.orig/programs/Xserver/hw/xfree86/os-support/bus/Pci.c (+10 lines)
597	return bits;	597	return bits;
598	}	598	}
599		599
		600	void
		601	pciInfoFromTag(PCITAG tag, int domainnum, int busnum,
		602	int devnum, int funcnum)
		603	{
		604	*domainnum = PCI_DOM_FROM_TAG(tag);
		605	*busnum = PCI_BUS_NO_DOMAIN(PCI_BUS_FROM_TAG(tag));
		606	*devnum = PCI_DEV_FROM_TAG(tag);
		607	*funcnum = PCI_FUNC_FROM_TAG(tag);
		608	}
		609
600	PCITAG	610	PCITAG
601	pciTag(int busnum, int devnum, int funcnum)	611	pciTag(int busnum, int devnum, int funcnum)
602	{	612	{

Lines 55-60 Link Here

(-)xc.orig/programs/Xserver/hw/xfree86/os-support/bus/linuxPci.c (-24 / +142 lines)
55	#include "xf86Priv.h"	55	#include "xf86Priv.h"
56	#include "xf86_OSlib.h"	56	#include "xf86_OSlib.h"
57	#include "Pci.h"	57	#include "Pci.h"
		58	#include <dirent.h>
58		59
59	/*	60	/*
60	* linux platform specific PCI access functions -- using /proc/bus/pci	61	* linux platform specific PCI access functions -- using /proc/bus/pci
Lines 130-167 linuxPciInit() Link Here
130	static int	131	static int
131	linuxPciOpenFile(PCITAG tag, Bool write)	132	linuxPciOpenFile(PCITAG tag, Bool write)
132	{	133	{
133	static int lbus,ldev,lfunc,fd = -1,is_write = 0;	134	static int ldomain, lbus,ldev,lfunc,fd = -1,is_write = 0;
134	int bus, dev, func;	135	int domain, bus, dev, func;
135	char file[32];	136	char file[32];
136	struct stat ignored;	137	struct stat ignored;
137		138
138	bus = PCI_BUS_FROM_TAG(tag);	139	domain = PCI_DOM_FROM_TAG(tag);
		140	bus = PCI_BUS_NO_DOMAIN(PCI_BUS_FROM_TAG(tag));
139	dev = PCI_DEV_FROM_TAG(tag);	141	dev = PCI_DEV_FROM_TAG(tag);
140	func = PCI_FUNC_FROM_TAG(tag);	142	func = PCI_FUNC_FROM_TAG(tag);
141	if (fd == -1 \|\| (write && (!is_write))	143
142	\|\| bus != lbus \|\| dev != ldev \|\| func != lfunc) {	144	if (fd == -1 \|\| (write && (!is_write)) \|\| bus != lbus
		145	\|\| dev != ldev \|\| func != lfunc \|\| domain != ldomain) {
		146
143	if (fd != -1)	147	if (fd != -1)
144	close(fd);	148	close(fd);
145	if (bus < 256) {	149	if (bus < 256) {
146	sprintf(file,"/proc/bus/pci/%02x",bus);	150	sprintf(file, "/proc/bus/pci/%04x:%02x", domain, bus);
147	if (stat(file, &ignored) < 0)	151	if (stat(file, &ignored) < 0) {
148	sprintf(file, "/proc/bus/pci/0000:%02x/%02x.%1x",	152	if (domain == 0)
149	bus, dev, func);	153	sprintf(file, "/proc/bus/pci/%02x/%02x.%1x",
150	else	154	bus, dev, func);
151	sprintf(file, "/proc/bus/pci/%02x/%02x.%1x",	155	else goto bail;
152	bus, dev, func);	156	} else
		157	sprintf(file, "/proc/bus/pci/%04x:%02x/%02x.%1x",
		158	domain, bus, dev, func);
153	} else {	159	} else {
154	sprintf(file,"/proc/bus/pci/%04x",bus);	160	sprintf(file, "/proc/bus/pci/%04x:%04x", domain, bus);
155	if (stat(file, &ignored) < 0)	161	if (stat(file, &ignored) < 0) {
156	sprintf(file, "/proc/bus/pci/0000:%04x/%02x.%1x",	162	if (domain == 0)
157	bus, dev, func);	163	sprintf(file, "/proc/bus/pci/%04x/%04x.%1x",
158	else	164	bus, dev, func);
159	sprintf(file, "/proc/bus/pci/%04x/%02x.%1x",	165	else goto bail;
160	bus, dev, func);	166	} else
		167	sprintf(file, "/proc/bus/pci/%04x:%04x/%02x.%1x",
		168	domain, bus, dev, func);
161	}	169	}
162	if (write) {	170	if (write) {
163	fd = open(file,O_RDWR);	171	fd = open(file,O_RDWR);
164	if (fd != -1) is_write = TRUE;	172	if (fd != -1) is_write = TRUE;
165	} else switch (is_write) {	173	} else switch (is_write) {
166	case TRUE:	174	case TRUE:
167	fd = open(file,O_RDWR);	175	fd = open(file,O_RDWR);
Lines 171-177 linuxPciOpenFile(PCITAG tag, Bool write) Link Here
171	fd = open(file,O_RDONLY);	179	fd = open(file,O_RDONLY);
172	is_write = FALSE;	180	is_write = FALSE;
173	}	181	}
174		182	bail:
		183	ldomain = domain;
175	lbus = bus;	184	lbus = bus;
176	ldev = dev;	185	ldev = dev;
177	lfunc = func;	186	lfunc = func;
Lines 491-497 xf86GetPciDomain(PCITAG Tag) Link Here
491	pPCI = xf86GetPciHostConfigFromTag(Tag);	500	pPCI = xf86GetPciHostConfigFromTag(Tag);
492		501
493	if (pPCI && (result = PCI_DOM_FROM_BUS(pPCI->busnum)))	502	if (pPCI && (result = PCI_DOM_FROM_BUS(pPCI->busnum)))
494	return result;	503	return result + 1;
495		504
496	if (!pPCI \|\| pPCI->fakeDevice)	505	if (!pPCI \|\| pPCI->fakeDevice)
497	return 1; /* Domain 0 is reserved */	506	return 1; /* Domain 0 is reserved */
Lines 724-730 xf86ReadDomainMemory(PCITAG Tag, ADDRESS Link Here
724	struct stat st;	733	struct stat st;
725		734
726	dom = PCI_DOM_FROM_TAG(Tag);	735	dom = PCI_DOM_FROM_TAG(Tag);
727	bus = PCI_BUS_FROM_TAG(Tag);	736	bus = PCI_BUS_NO_DOMAIN(PCI_BUS_FROM_TAG(Tag));
728	dev = PCI_DEV_FROM_TAG(Tag);	737	dev = PCI_DEV_FROM_TAG(Tag);
729	func = PCI_FUNC_FROM_TAG(Tag);	738	func = PCI_FUNC_FROM_TAG(Tag);
730	sprintf(file, "/sys/devices/pci%04x:%02x/%04x:%02x:%02x.%1x/rom",	739	sprintf(file, "/sys/devices/pci%04x:%02x/%04x:%02x:%02x.%1x/rom",
Lines 892-894 xf86AccResFromOS(resPtr pRes) Link Here
892	}	901	}
893		902
894	#endif /* !INCLUDE_XF86_NO_DOMAIN */	903	#endif /* !INCLUDE_XF86_NO_DOMAIN */
		904
		905	#ifdef __ia64__
		906	static PCITAG ia64linuxPciFindFirst(void);
		907	static PCITAG ia64linuxPciFindNext(void);
		908
		909
		910	void
		911	ia64linuxPciInit()
		912	{
		913	struct stat st;
		914	/* Be a little paranoid here and only use this code for Altix systems.
		915	* It is generic, so it should work on any system, but depends on
		916	* /proc/bus/pci entries for each domain/bus combination. Altix is
		917	* guaranteed a recent enough kernel to have them.
		918	*/
		919	if (stat("/proc/sgi_sn/licenseID", &st)) {
		920	return linuxPciInit();
		921	}
		922	if ((xf86Info.pciFlags == PCIForceNone) \|\|
		923	(-1 == stat("/proc/bus/pci", &st))) {
		924	/* when using this as default for all linux architectures,
		925	we'll need a fallback for 2.0 kernels here */
		926	return;
		927	}
		928	pciNumBuses = 1;
		929	pciBusInfo[0] = &linuxPci0;
		930	pciFindFirstFP = ia64linuxPciFindFirst;
		931	pciFindNextFP = ia64linuxPciFindNext;
		932	}
		933
		934	static DIR *busdomdir;
		935	static DIR *devdir;
		936
		937	static PCITAG
		938	ia64linuxPciFindFirst(void)
		939	{
		940	busdomdir = opendir("/proc/bus/pci");
		941	devdir = NULL;
		942
		943	return ia64linuxPciFindNext();
		944	}
		945
		946	static struct dirent getnextbus(int domain, int *bus)
		947	{
		948	struct dirent *entry;
		949	int dombus;
		950
		951	for (;;) {
		952	entry = readdir(busdomdir);
		953	if (entry == NULL) {
		954	*domain = 0;
		955	*bus = 0;
		956	closedir(busdomdir);
		957	return NULL;
		958	}
		959	if (sscanf(entry->d_name, "%04x:%02x", domain, bus) != 2)
		960	continue;
		961	dombus = PCI_MAKE_BUS(domain, bus);
		962
		963	if (pciNumBuses <= dombus)
		964	pciNumBuses = dombus + 1;
		965	if (!pciBusInfo[dombus]) {
		966	pciBusInfo[dombus] = xnfalloc(sizeof(pciBusInfo_t));
		967	pciBusInfo[dombus] = pciBusInfo[0];
968	}
969
970	return entry;
971	}
972	}
973
974	static PCITAG
975	ia64linuxPciFindNext(void)
976	{
977	struct dirent *entry;
978	char file[40];
979	static int bus, dev, func, domain;
980	PCITAG pciDeviceTag;
981	CARD32 devid;
982
983	for (;;) {
984	if (devdir == NULL) {
985	entry = getnextbus(&domain, &bus);
986	if (!entry)
987	return PCI_NOT_FOUND;
988	snprintf(file, 40, "/proc/bus/pci/%s", entry->d_name);
989	devdir = opendir(file);
990	if (!devdir)
991	return PCI_NOT_FOUND;
992
993	}
994
995	entry = readdir(devdir);
996
997	if (entry == NULL) {
998	closedir(devdir);
999	devdir = NULL;
1000	continue;
1001	}
1002
1003	if (sscanf(entry->d_name, "%02x . %01x", &dev, &func) == 2) {
1004	pciDeviceTag = PCI_MAKE_TAG(PCI_MAKE_BUS(domain, bus), dev, func);
1005	devid = pciReadLong(pciDeviceTag, PCI_ID_REG);
1006	if ((devid & pciDevidMask) == pciDevid)
1007	/* Yes - Return it. Otherwise, next device */
1008	return pciDeviceTag;
1009	}
1010	}
1011	}
1012	#endif

Lines 41-53 static pciDevice *get_dev_on_bus(unsigne Link Here

(-)xc.orig/programs/Xserver/hw/xfree86/os-support/bus/altixPCI.c (-3 / +6 lines)
41	static void get_bridge_info(pciBusInfo_t bus_info, pciDevice pdev)	41	static void get_bridge_info(pciBusInfo_t bus_info, pciDevice pdev)
42	{	42	{
43	unsigned int parent_segnum, segnum = PCI_DOM_FROM_TAG(pdev->tag);	43	unsigned int parent_segnum, segnum = PCI_DOM_FROM_TAG(pdev->tag);
44	unsigned int parent_busnum, busnum = pdev->busnum;	44	unsigned int parent_busnum, parent_nodombus, busnum = pdev->busnum;
		45	unsigned int nodombus = PCI_BUS_NO_DOMAIN(PCI_BUS_FROM_TAG(pdev->tag));
45	char bridge_path[] = "/sys/class/pci_bus/0000:00/bridge";	46	char bridge_path[] = "/sys/class/pci_bus/0000:00/bridge";
46	char bridge_target[] = "../../../devices/pci0000:00";	47	char bridge_target[] = "../../../devices/pci0000:00";
47		48
48	/* Path to this device's bridge */	49	/* Path to this device's bridge */
49	sprintf(bridge_path, "/sys/class/pci_bus/%04x:%02x/bridge", segnum,	50	sprintf(bridge_path, "/sys/class/pci_bus/%04x:%02x/bridge", segnum,
50	busnum);	51	nodombus);
51		52
52	if (readlink(bridge_path, bridge_target, strlen(bridge_target)) < 0) {	53	if (readlink(bridge_path, bridge_target, strlen(bridge_target)) < 0) {
53	perror("failed to dereference bridge link");	54	perror("failed to dereference bridge link");
Lines 56-62 static void get_bridge_info(pciBusInfo_t Link Here
56	}	57	}
57		58
58	sscanf(bridge_target, "../../../devices/pci%04x:%02x", &parent_segnum,	59	sscanf(bridge_target, "../../../devices/pci%04x:%02x", &parent_segnum,
59	&parent_busnum);	60	&parent_nodombus);
		61
		62	parent_busnum = PCI_MAKE_BUS(parent_segnum, parent_nodombus);
60		63
61	/*	64	/*
62	* If there's no bridge or the bridge points to the device, use	65	* If there's no bridge or the bridge points to the device, use

Lines 28-43 FILE *xf86OSLinuxPCIFile = NULL; Link Here

(-)xc.orig/programs/Xserver/hw/xfree86/os-support/linux/lnx_pci.c (-4 / +77 lines)
28	Bool	28	Bool
29	xf86GetPciSizeFromOS(PCITAG tag, int index, int* bits)	29	xf86GetPciSizeFromOS(PCITAG tag, int index, int* bits)
30	{	30	{
		31	FILE *file;
31	char c[0x200];	32	char c[0x200];
32	char *res;	33	char *res;
33	unsigned int bus, devfn, dev, fn;	34	unsigned int domain, bus, devfn, dev, fn;
34	unsigned PCIADDR_TYPE size[7];	35	unsigned PCIADDR_TYPE size[7];
35	unsigned int num;	36	unsigned int num;
36	signed PCIADDR_TYPE Size;	37	signed PCIADDR_TYPE Size;
		38	int resource;
		39	unsigned PCIADDR_TYPE begin, end;
37		40
38	if (index > 7)	41	if (index > 7)
39	return FALSE;	42	return FALSE;
40		43
		44	pciInfoFromTag(tag, &domain, &bus, &dev, &fn);
		45
		46	sprintf(c, "/sys/devices/pci%04x:%02x/%04x:%02x:%02x.%1x/resource",
		47	domain, bus, domain, bus, dev, fn);
		48	if (file = fopen(c, "r")) {
		49	for (resource=0; resource != index; resource++)
		50	fgets(c, 0x1ff, file);
		51	res = fgets(c, 0x1ff, file);
		52	num = sscanf(res, PCIADDR_FMT " " PCIADDR_FMT " " PCIADDR_IGNORE_FMT,
		53	&begin, &end);
		54	if (num == 2) {
		55	Size = end - begin;
		56	while (Size & ((PCIADDR_TYPE) 0x01)) {
		57	Size = Size >> ((PCIADDR_TYPE) 1);
		58	(*bits)++;
		59	}
		60	fclose(file);
		61	return TRUE;
		62	}
		63	fclose(file);
		64	}
		65
41	if (!xf86OSLinuxPCIFile && \	66	if (!xf86OSLinuxPCIFile && \
42	!(xf86OSLinuxPCIFile = fopen("/proc/bus/pci/devices","r")))	67	!(xf86OSLinuxPCIFile = fopen("/proc/bus/pci/devices","r")))
43	return FALSE;	68	return FALSE;
Lines 99-111 xf86GetPciOffsetFromOS(PCITAG tag, int i Link Here
99	FILE *file;	124	FILE *file;
100	char c[0x200];	125	char c[0x200];
101	char *res;	126	char *res;
102	unsigned int bus, devfn, dev, fn;	127	unsigned int domain, bus, devfn, dev, fn;
103	unsigned PCIADDR_TYPE offset[7];	128	unsigned PCIADDR_TYPE offset[7];
104	unsigned int num;	129	unsigned int num;
		130	int resource;
105		131
106	if (index > 7)	132	if (index > 7)
107	return FALSE;	133	return FALSE;
108		134
		135	pciInfoFromTag(tag, &domain, &bus, &dev, &fn);
		136
		137	sprintf(c, "/sys/devices/pci%04x:%02x/%04x:%02x:%02x.%1x/resource",
		138	domain, bus, domain, bus, dev, fn);
		139	if (file = fopen(c, "r")) {
		140	for (resource=0; resource != index; resource++)
		141	fgets(c, 0x1ff, file);
		142	res = fgets(c, 0x1ff, file);
		143	num = sscanf(res, PCIADDR_FMT " " PCIADDR_IGNORE_FMT " " PCIADDR_IGNORE_FMT,
		144	&offset[0]);
		145	if (num == 1) {
		146	*bases = offset[0];
		147	fclose(file);
		148	return TRUE;
		149	}
		150	fclose(file);
		151	}
		152
109	if (!(file = fopen("/proc/bus/pci/devices","r")))	153	if (!(file = fopen("/proc/bus/pci/devices","r")))
110	return FALSE;	154	return FALSE;
111	do {	155	do {
Lines 159-169 xf86GetOSOffsetFromPCI(PCITAG tag, int s Link Here
159	FILE *file;	203	FILE *file;
160	char c[0x200];	204	char c[0x200];
161	char *res;	205	char *res;
162	unsigned int bus, devfn, dev, fn;	206	unsigned int domain, bus, devfn, dev, fn;
163	unsigned PCIADDR_TYPE offset[7];	207	unsigned PCIADDR_TYPE offset[7];
164	unsigned PCIADDR_TYPE size[7];	208	unsigned PCIADDR_TYPE size[7];
165	unsigned int num;	209	unsigned int num;
166	unsigned int ndx;	210	unsigned int ndx;
		211	unsigned PCIADDR_TYPE begin,end;
		212
		213	pciInfoFromTag(tag, &domain, &bus, &dev, &fn);
		214
		215	sprintf(c, "/sys/devices/pci%04x:%02x/%04x:%02x:%02x.%1x/resource",
		216	domain, bus, domain, bus, dev, fn);
		217	if (file = fopen(c, "r")) {
		218	unsigned long savePtr;
		219	for (ndx=0; ndx < 7; ndx++) {
		220	res = fgets(c, 0x1ff, file);
		221	if (!res)
		222	break;
		223	num = sscanf(res, PCIADDR_FMT " " PCIADDR_FMT " " PCIADDR_IGNORE_FMT,
		224	&begin, &end);
		225	if (num == 2) {
		226	if (ndx == 6)
		227	savePtr = (0xFFFFFFF0) &
		228	pciReadLong(tag, PCI_CMD_BIOS_REG);
		229	else /* this the ROM bar */
		230	savePtr = (0xFFFFFFF0) &
		231	pciReadLong(tag, PCI_CMD_BASE_REG + (0x4 * ndx));
		232	if (base >= savePtr && base <= (savePtr + (end - begin))) {
		233	fclose(file);
		234	return ( ~(0xFUL) & (begin + (base - savePtr)));
		235	}
		236	}
		237	}
		238	fclose(file);
		239	}
167		240
168	if (!(file = fopen("/proc/bus/pci/devices","r")))	241	if (!(file = fopen("/proc/bus/pci/devices","r")))
169	return 0;	242	return 0;