pci.c

详细介绍了一篇关于pci开发的接口芯片

{
	int i, min, max;
	long order;

	min = 0,
	max = sizeof(dev_info) / sizeof(dev_info[0]) - 1;
	for ( ; ; )
	{
	i = (min + max) >> 1;

	order = dev_info[i].vendor - vendor;
	if (!order)
			order = dev_info[i].device - dev;
	
	if (order < 0) {
		min = i + 1;
		if (min > max)
		return(0);
		continue;
	}

	if (order > 0) {
		max = i - 1;
		if (min > max)
		return(0);
		continue;
	}
	return(&dev_info[i]);
	}
}

const char *
pci_strclass(unsigned int class)
{
	switch (class) {
	case PCI_CLASS_NOT_DEFINED:		return "Non-VGA";
	case PCI_CLASS_NOT_DEFINED_VGA:	return "VGA compatible";

	case PCI_CLASS_STORAGE_SCSI:	return "SCSI interface";
	case PCI_CLASS_STORAGE_IDE:		return "IDE interface";
	case PCI_CLASS_STORAGE_FLOPPY:	return "Floppy disk";
	case PCI_CLASS_STORAGE_IPI:		return "IPI bus";
	case PCI_CLASS_STORAGE_RAID:	return "RAID bus";
	case PCI_CLASS_STORAGE_OTHER:	return "Unknown mass storage";

	case PCI_CLASS_NETWORK_ETHERNET:	return "Ethernet";
	case PCI_CLASS_NETWORK_TOKEN_RING:	return "Token ring";
	case PCI_CLASS_NETWORK_FDDI:	return "FDDI";
	case PCI_CLASS_NETWORK_ATM:		return "ATM";
	case PCI_CLASS_NETWORK_OTHER:	return "Network";

	case PCI_CLASS_DISPLAY_VGA:		return "VGA compatible";
	case PCI_CLASS_DISPLAY_XGA:		return "XGA compatible";
	case PCI_CLASS_DISPLAY_OTHER:	return "Generic Display";

	case PCI_CLASS_MULTIMEDIA_VIDEO:	return "Multimedia video";
	case PCI_CLASS_MULTIMEDIA_AUDIO:	return "Multimedia audio";
	case PCI_CLASS_MULTIMEDIA_OTHER:	return "Multimedia";

	case PCI_CLASS_MEMORY_RAM:		return "RAM memory";
	case PCI_CLASS_MEMORY_FLASH:	return "FLASH memory";
	case PCI_CLASS_MEMORY_OTHER:	return "Memory";

	case PCI_CLASS_BRIDGE_HOST:		return "Host bridge";
	case PCI_CLASS_BRIDGE_ISA:		return "ISA bridge";
	case PCI_CLASS_BRIDGE_EISA:		return "EISA bridge";
	case PCI_CLASS_BRIDGE_MC:		return "MicroChannel bridge";
	case PCI_CLASS_BRIDGE_PCI:		return "PCI bridge";
	case PCI_CLASS_BRIDGE_PCMCIA:	return "PCMCIA bridge";
	case PCI_CLASS_BRIDGE_NUBUS:	return "NuBus bridge";
	case PCI_CLASS_BRIDGE_CARDBUS:	return "CardBus bridge";
	case PCI_CLASS_BRIDGE_OTHER:	return "Bridge";

	case PCI_CLASS_COMMUNICATION_SERIAL:	return "Serial";
	case PCI_CLASS_COMMUNICATION_PARALLEL:	return "Parallel";
	case PCI_CLASS_COMMUNICATION_OTHER:		return "Communication";

	case PCI_CLASS_SYSTEM_PIC:		return "PIC";
	case PCI_CLASS_SYSTEM_DMA:		return "DMA";
	case PCI_CLASS_SYSTEM_TIMER:	return "Timer";
	case PCI_CLASS_SYSTEM_RTC:		return "RTC";
	case PCI_CLASS_SYSTEM_OTHER:	return "System peripheral";

	case PCI_CLASS_INPUT_KEYBOARD:	return "Keyboard";
	case PCI_CLASS_INPUT_PEN:		return "Digitizer Pen";
	case PCI_CLASS_INPUT_MOUSE:		return "Mouse";
	case PCI_CLASS_INPUT_OTHER:		return "Input device";

	case PCI_CLASS_DOCKING_GENERIC:	return "Generic Docking Station";
	case PCI_CLASS_DOCKING_OTHER:	return "Docking Station";

	case PCI_CLASS_PROCESSOR_386:		return "386";
	case PCI_CLASS_PROCESSOR_486:		return "486";
	case PCI_CLASS_PROCESSOR_PENTIUM:	return "Pentium";
	case PCI_CLASS_PROCESSOR_ALPHA:		return "Alpha";
	case PCI_CLASS_PROCESSOR_POWERPC:	return "Power PC";
	case PCI_CLASS_PROCESSOR_CO:		return "Co-processor";

	case PCI_CLASS_SERIAL_FIREWIRE:	return "FireWire (IEEE 1394)";
	case PCI_CLASS_SERIAL_ACCESS:	return "ACCESS Bus";
	case PCI_CLASS_SERIAL_SSA:		return "SSA";
	case PCI_CLASS_SERIAL_USB:		return "USB Controller";
	case PCI_CLASS_SERIAL_FIBER:	return "Fiber Channel";

	default:
		return "Unknown class";
	}
}

const char *
pci_strvendor(unsigned int vendor)
{
	switch (vendor) {
	case PCI_VENDOR_ID_COMPAQ:	return "Compaq";
	case PCI_VENDOR_ID_NCR:		return "NCR";
	case PCI_VENDOR_ID_ATI:		return "ATI";
	case PCI_VENDOR_ID_VLSI:	return "VLSI";
	case PCI_VENDOR_ID_ADL:		return "Advance Logic";
	case PCI_VENDOR_ID_NS:		return "NS";
	case PCI_VENDOR_ID_TSENG:	return "Tseng'Lab";
	case PCI_VENDOR_ID_WEITEK:	return "Weitek";
	case PCI_VENDOR_ID_DEC:		return "DEC";
	case PCI_VENDOR_ID_CIRRUS:	return "Cirrus Logic";
	case PCI_VENDOR_ID_IBM:		return "IBM";
	case PCI_VENDOR_ID_WD:		return "Western Digital";
	case PCI_VENDOR_ID_AMD:		return "AMD";
	case PCI_VENDOR_ID_TRIDENT:	return "Trident";
	case PCI_VENDOR_ID_AI:		return "Acer Incorporated";
	case PCI_VENDOR_ID_MATROX:	return "Matrox";
	case PCI_VENDOR_ID_CT:		return "Chips & Technologies";
	case PCI_VENDOR_ID_MIRO:	return "Miro";
	case PCI_VENDOR_ID_FD:		return "Future Domain";
	case PCI_VENDOR_ID_SI:		return "Silicon Integrated Systems";
	case PCI_VENDOR_ID_HP:		return "Hewlett Packard";
	case PCI_VENDOR_ID_PCTECH:	return "PCTECH";
	case PCI_VENDOR_ID_DPT:		return "DPT";
	case PCI_VENDOR_ID_OPTI:	return "OPTI";
	case PCI_VENDOR_ID_SGS:		return "SGS Thomson";
	case PCI_VENDOR_ID_BUSLOGIC:return "BusLogic";
	case PCI_VENDOR_ID_OAK: 	return "OAK";
	case PCI_VENDOR_ID_WINBOND2:return "Winbond";
	case PCI_VENDOR_ID_MOTOROLA:return "Motorola";
	case PCI_VENDOR_ID_PROMISE:	return "Promise Technology";
	case PCI_VENDOR_ID_N9:		return "Number Nine";
	case PCI_VENDOR_ID_UMC:		return "UMC";
	case PCI_VENDOR_ID_X:		return "X TECHNOLOGY";
	case PCI_VENDOR_ID_NEXGEN:	return "Nexgen";
	case PCI_VENDOR_ID_QLOGIC:	return "Q Logic";
	case PCI_VENDOR_ID_LEADTEK:	return "Leadtek Research";
	case PCI_VENDOR_ID_CONTAQ:	return "Contaq";
	case PCI_VENDOR_ID_FOREX:	return "Forex";
	case PCI_VENDOR_ID_OLICOM:	return "Olicom";
	case PCI_VENDOR_ID_CMD:		return "CMD";
	case PCI_VENDOR_ID_VISION:	return "Vision";
	case PCI_VENDOR_ID_BROOKTREE:	return "Brooktree";
	case PCI_VENDOR_ID_SIERRA:	return "Sierra";
	case PCI_VENDOR_ID_ACC:		return "ACC MICROELECTRONICS";
	case PCI_VENDOR_ID_WINBOND:	return "Winbond";
	case PCI_VENDOR_ID_3COM:	return "3Com";
	case PCI_VENDOR_ID_AL:		return "Acer Labs";
	case PCI_VENDOR_ID_NEOMAGIC:return "Neomagic";
	case PCI_VENDOR_ID_ASP:		return "Advanced System Products";
	case PCI_VENDOR_ID_CERN:	return "CERN";
	case PCI_VENDOR_ID_IMS:		return "IMS";
	case PCI_VENDOR_ID_TEKRAM2:	return "Tekram";
	case PCI_VENDOR_ID_TUNDRA:	return "Tundra";
	case PCI_VENDOR_ID_AMCC:	return "AMCC";
	case PCI_VENDOR_ID_INTERG:	return "Intergraphics";
	case PCI_VENDOR_ID_REALTEK:	return "Realtek";
	case PCI_VENDOR_ID_INIT:	return "Initio Corp";
	case PCI_VENDOR_ID_VIA:		return "VIA Technologies";
	case PCI_VENDOR_ID_VORTEX:	return "VORTEX";
	case PCI_VENDOR_ID_EF:		return "Efficient Networks";
	case PCI_VENDOR_ID_FORE:	return "Fore Systems";
	case PCI_VENDOR_ID_IMAGINGTECH:	return "Imaging Technology";
	case PCI_VENDOR_ID_PLX:		return "PLX";
	case PCI_VENDOR_ID_ALLIANCE:return "Alliance";
	case PCI_VENDOR_ID_VMIC:	return "VMIC";
	case PCI_VENDOR_ID_DIGI:	return "Digi Intl.";
	case PCI_VENDOR_ID_MUTECH:	return "Mutech";
	case PCI_VENDOR_ID_TOSHIBA:	return "Toshiba";
	case PCI_VENDOR_ID_ZEITNET:	return "ZeitNet";
	case PCI_VENDOR_ID_OMEGA:	return "Omega Micro";
	case PCI_VENDOR_ID_SPECIALIX:return "Specialix";
	case PCI_VENDOR_ID_ZORAN:	return "Zoran";
	case PCI_VENDOR_ID_COMPEX:	return "Compex";
	case PCI_VENDOR_ID_RP:		return "Comtrol";
	case PCI_VENDOR_ID_CYCLADES:return "Cyclades";
	case PCI_VENDOR_ID_3DFX:	return "3Dfx";
	case PCI_VENDOR_ID_SIGMADES:return "Sigma Designs";
	case PCI_VENDOR_ID_OPTIBASE:return "Optibase";
	case PCI_VENDOR_ID_SYMPHONY:return "Symphony";
	case PCI_VENDOR_ID_TEKRAM:	return "Tekram";
	case PCI_VENDOR_ID_3DLABS:	return "3Dlabs";
	case PCI_VENDOR_ID_AVANCE:	return "Avance";
	case PCI_VENDOR_ID_S3:		return "S3 Inc.";
	case PCI_VENDOR_ID_INTEL:	return "Intel";
	case PCI_VENDOR_ID_KTI:		return "KTI";
	case PCI_VENDOR_ID_ADAPTEC:	return "Adaptec";
	case PCI_VENDOR_ID_ATRONICS:return "Atronics";
	case PCI_VENDOR_ID_ARK:		return "ARK Logic";
	default:
		return "Unknown vendor";
	}
}

const char *
pci_strdev(unsigned int vendor, unsigned int device)
{
	struct pci_dev_info *info;

	info = 	pci_lookup_dev(vendor, device);
	return info ? info->name : "Unknown device";
}


/*
** Convert some of the configuration space registers of the device at
** address (bus,devfn) into a string (possibly several lines each).
** The configuration string is stored starting at buf[len].  If the
** string would exceed the size of the buffer (SIZE), 0 is returned.
*/
int
sprint_dev_config(struct pci_devices *p, char *buf, int size)
{
	int len;

	len = 0;

	if (len + 80 > size)
		return -1;

	len += sprintf(buf + len, "Bus %2d: ", p->bus);
	if (pci_lookup_dev(p->vendor_id, p->device_id))
		len += sprintf(buf + len, " %s: %s %s",
			pci_strclass(p->base_class << 8), pci_strvendor(p->vendor_id),
				pci_strdev(p->vendor_id, p->device_id));
	else
		len += sprintf(buf + len, " %04X %04X", p->vendor_id, p->device_id);
	return(len);
}

/*
** Do a PCI bus scan to locate all PCI devices
*/
int
find_all_pci_devices(struct pci_devices *pci, int max_pci)
{
	byte last_pci_bus, dev_func;
	byte base_class, sub_class;
	byte devfun, dev;
	byte bus, bus_no;
	word ndx, vid, devid;
	int n_pci, found;

	if (pci_bios_present(NULL, NULL, &last_pci_bus) != OK)
		return(0);

	n_pci = -1;
	for (bus_no = 0; bus_no <= last_pci_bus; bus_no++) {
		for (dev = 0; dev <= 0x1f; dev++) {
			dev_func = dev << 3;
			if (read_configuration_word(bus_no, dev_func, 0, &vid) != OK)
				continue;
			if (vid == 0xffff) 
				continue;

			read_configuration_word(bus_no, dev_func, 2, &devid);
			read_configuration_byte(bus_no, dev_func, 0x0b, &base_class);
			read_configuration_byte(bus_no, dev_func, 0x0a, &sub_class);

			/* See if can find via find_pci_device */
			ndx = found = 0;
			do {
				if (find_pci_device(devid, vid, ndx, &bus, &devfun) != OK)
					break;
				if (bus == bus_no && devfun == dev_func) {

					if (++n_pci == max_pci)
						error_exit(4);
					if (vid == 0x10e8 && cur_pci_dev == -1)
						cur_pci_dev = n_pci;
					found = TRUE;
					pci[n_pci].bus = bus_no;
					pci[n_pci].vendor_id = vid;
					pci[n_pci].device_id = devid;
					pci[n_pci].sub_class = sub_class;
					pci[n_pci].base_class = base_class;
					pci[n_pci].device_and_function = dev_func;
				}
				ndx++;
			} while (!found);
		}
	}
	return(n_pci + 1);
}