blob: e0974f9873e6358bbf6175ef8e7e2314dbe4e01b [file] [log] [blame]
/* ----------------------------------------------------------------------- *
*
* Copyright 2006-2007 Erwan Velu - All Rights Reserved
*
* 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 AUTHORS OR COPYRIGHT
* HOLDERS 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.
*
* ----------------------------------------------------------------------- */
/*
* pci.c
*
* A module to extract pci informations
*/
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <console.h>
#include <sys/pci.h>
#include <com32.h>
#include <stdbool.h>
#include <ctype.h>
#include <syslinux/zio.h>
#include <dprintf.h>
#define MAX_LINE 512
/* removing any \n found in a string */
static void remove_eol(char *string)
{
int j = strlen(string);
int i = 0;
for (i = 0; i < j; i++)
if (string[i] == '\n')
string[i] = 0;
}
/* converting a hexa string into its numerical value */
static int hex_to_int(char *hexa)
{
return strtoul(hexa, NULL, 16);
}
/* Try to match any pci device to the appropriate kernel module */
/* it uses the modules.pcimap from the boot device */
int get_module_name_from_pcimap(struct pci_domain *domain,
char *modules_pcimap_path)
{
char line[MAX_LINE];
char module_name[21]; // the module name field is 21 char long
char delims[]=" "; // colums are separated by spaces
char vendor_id[16];
char product_id[16];
char sub_vendor_id[16];
char sub_product_id[16];
FILE *f;
struct pci_device *dev=NULL;
/* Intializing the linux_kernel_module for each pci device to "unknown" */
/* adding a dev_info member if needed */
for_each_pci_func(dev, domain) {
/* initialize the dev_info structure if it doesn't exist yet. */
if (! dev->dev_info) {
dev->dev_info = zalloc(sizeof *dev->dev_info);
if (!dev->dev_info)
return -1;
}
for (int i=0;i<MAX_KERNEL_MODULES_PER_PCI_DEVICE;i++) {
if (strlen(dev->dev_info->linux_kernel_module[i])==0)
strlcpy(dev->dev_info->linux_kernel_module[i], "unknown",7);
}
}
/* Opening the modules.pcimap (of a linux kernel) from the boot device */
f=zfopen(modules_pcimap_path, "r");
if (!f)
return -ENOMODULESPCIMAP;
strcpy(vendor_id,"0000");
strcpy(product_id,"0000");
strcpy(sub_product_id,"0000");
strcpy(sub_vendor_id,"0000");
/* for each line we found in the modules.pcimap */
while ( fgets(line, sizeof line, f) ) {
/* skipping unecessary lines */
if ((line[0] == '#') || (line[0] == ' ') || (line[0] == 10))
continue;
char *result = NULL;
int field=0;
/* looking for the next field */
result = strtok(line, delims);
while( result != NULL ) {
/* if the column is larger than 1 char */
/* multiple spaces generates some empty fields */
if (strlen(result)>1) {
switch (field) {
/* About case 0, the kernel module name is featuring '_' or '-'
* in the module name whereas modules.alias is only using '_'.
* To avoid kernel modules duplication, let's rename all '-' in '_'
* to match what modules.alias provides */
case 0:chrreplace(result,'-','_');strcpy(module_name,result); break;
case 1:strcpy(vendor_id,result); break;
case 2:strcpy(product_id,result); break;
case 3:strcpy(sub_vendor_id,result); break;
case 4:strcpy(sub_product_id,result); break;
}
field++;
}
/* Searching the next field */
result = strtok( NULL, delims );
}
int int_vendor_id=hex_to_int(vendor_id);
int int_sub_vendor_id=hex_to_int(sub_vendor_id);
int int_product_id=hex_to_int(product_id);
int int_sub_product_id=hex_to_int(sub_product_id);
/* if a pci_device matches an entry, fill the linux_kernel_module with
the appropriate kernel module */
for_each_pci_func(dev, domain) {
if (int_vendor_id == dev->vendor &&
int_product_id == dev->product &&
(int_sub_product_id & dev->sub_product)
== dev->sub_product &&
(int_sub_vendor_id & dev->sub_vendor)
== dev->sub_vendor) {
bool found=false;
/* Scan all known kernel modules for this pci device */
for (int i=0; i<dev->dev_info->linux_kernel_module_count; i++) {
/* Try to detect if we already knew the same kernel module*/
if (strstr(dev->dev_info->linux_kernel_module[i], module_name)) {
found=true;
break;
}
}
/* If we don't have this kernel module, let's add it */
if (!found) {
strcpy(dev->dev_info->linux_kernel_module[dev->dev_info->linux_kernel_module_count], module_name);
dev->dev_info->linux_kernel_module_count++;
}
}
}
}
fclose(f);
return 0;
}
/* Try to match any pci device to the appropriate class name */
/* it uses the pci.ids from the boot device */
int get_class_name_from_pci_ids(struct pci_domain *domain, char *pciids_path)
{
char line[MAX_LINE];
char class_name[PCI_CLASS_NAME_SIZE];
char sub_class_name[PCI_CLASS_NAME_SIZE];
char class_id_str[5];
char sub_class_id_str[5];
FILE *f;
struct pci_device *dev;
bool class_mode = false;
/* Intializing the vendor/product name for each pci device to "unknown" */
/* adding a dev_info member if needed */
for_each_pci_func(dev, domain) {
/* initialize the dev_info structure if it doesn't exist yet. */
if (!dev->dev_info) {
dev->dev_info = zalloc(sizeof *dev->dev_info);
if (!dev->dev_info)
return -1;
}
strlcpy(dev->dev_info->class_name, "unknown", 7);
}
/* Opening the pci.ids from the boot device */
f = zfopen(pciids_path, "r");
if (!f)
return -ENOPCIIDS;
/* for each line we found in the pci.ids */
while (fgets(line, sizeof line, f)) {
/* Skipping uncessary lines */
if ((line[0] == '#') || (line[0] == ' ') || (line[0] == 10))
continue;
/* Until we found a line starting with a 'C', we are not parsing classes */
if (line[0] == 'C')
class_mode = true;
if (class_mode == false)
continue;
strlcpy(class_name, "unknown", 7);
/* If the line doesn't start with a tab, it means that's a class name */
if (line[0] != '\t') {
/* ignore the two first char and then copy 2 chars (class id) */
strlcpy(class_id_str, &line[2], 2);
class_id_str[2] = 0;
/* the class name is the next field */
strlcpy(class_name, skipspace(strstr(line, " ")),
PCI_CLASS_NAME_SIZE - 1);
remove_eol(class_name);
int int_class_id_str = hex_to_int(class_id_str);
/* assign the class_name to any matching pci device */
for_each_pci_func(dev, domain) {
if (int_class_id_str == dev->class[2]) {
strlcpy(dev->dev_info->class_name, class_name,
PCI_CLASS_NAME_SIZE - 1);
/* This value is usually the main category */
strlcpy(dev->dev_info->category_name, class_name + 4,
PCI_CLASS_NAME_SIZE - 1);
}
}
/* if we have a tab + a char, it means this is a sub class name */
} else if ((line[0] == '\t') && (line[1] != '\t')) {
/* the sub class name the second field */
strlcpy(sub_class_name, skipspace(strstr(line, " ")),
PCI_CLASS_NAME_SIZE - 1);
remove_eol(sub_class_name);
/* the sub class id is first field */
strlcpy(sub_class_id_str, &line[1], 2);
sub_class_id_str[2] = 0;
int int_class_id_str = hex_to_int(class_id_str);
int int_sub_class_id_str = hex_to_int(sub_class_id_str);
/* assign the product_name to any matching pci device */
for_each_pci_func(dev, domain) {
if (int_class_id_str == dev->class[2] &&
int_sub_class_id_str == dev->class[1])
strlcpy(dev->dev_info->class_name, sub_class_name,
PCI_CLASS_NAME_SIZE - 1);
}
}
}
fclose(f);
return 0;
}
/* Try to match any pci device to the appropriate vendor and product name */
/* it uses the pci.ids from the boot device */
int get_name_from_pci_ids(struct pci_domain *domain, char *pciids_path)
{
char line[MAX_LINE];
char vendor[PCI_VENDOR_NAME_SIZE];
char vendor_id[5];
char product[PCI_PRODUCT_NAME_SIZE];
char product_id[5];
char sub_product_id[5];
char sub_vendor_id[5];
FILE *f;
struct pci_device *dev;
bool skip_to_next_vendor = false;
uint16_t int_vendor_id;
uint16_t int_product_id;
uint16_t int_sub_product_id;
uint16_t int_sub_vendor_id;
/* Intializing the vendor/product name for each pci device to "unknown" */
/* adding a dev_info member if needed */
for_each_pci_func(dev, domain) {
/* initialize the dev_info structure if it doesn't exist yet. */
if (!dev->dev_info) {
dev->dev_info = zalloc(sizeof *dev->dev_info);
if (!dev->dev_info)
return -1;
}
strlcpy(dev->dev_info->vendor_name, "unknown", 7);
strlcpy(dev->dev_info->product_name, "unknown", 7);
}
/* Opening the pci.ids from the boot device */
f = zfopen(pciids_path, "r");
if (!f)
return -ENOPCIIDS;
strlcpy(vendor_id, "0000", 4);
strlcpy(product_id, "0000", 4);
strlcpy(sub_product_id, "0000", 4);
strlcpy(sub_vendor_id, "0000", 4);
/* for each line we found in the pci.ids */
while (fgets(line, sizeof line, f)) {
/* Skipping uncessary lines */
if ((line[0] == '#') || (line[0] == ' ') || (line[0] == 'C') ||
(line[0] == 10))
continue;
/* If the line doesn't start with a tab, it means that's a vendor id */
if (line[0] != '\t') {
/* the 4 first chars are the vendor_id */
strlcpy(vendor_id, line, 4);
/* the vendor name is the next field */
vendor_id[4] = 0;
strlcpy(vendor, skipspace(strstr(line, " ")),
PCI_VENDOR_NAME_SIZE - 1);
remove_eol(vendor);
/* init product_id, sub_product and sub_vendor */
strlcpy(product_id, "0000", 4);
strlcpy(sub_product_id, "0000", 4);
strlcpy(sub_vendor_id, "0000", 4);
/* Unless we found a matching device, we have to skip to the next vendor */
skip_to_next_vendor = true;
int_vendor_id = hex_to_int(vendor_id);
/* Iterate in all pci devices to find a matching vendor */
for_each_pci_func(dev, domain) {
/* if one device that match this vendor */
if (int_vendor_id == dev->vendor) {
/* copy the vendor name for this device */
strlcpy(dev->dev_info->vendor_name, vendor,
PCI_VENDOR_NAME_SIZE - 1);
/* Some pci devices match this vendor, so we have to found them */
skip_to_next_vendor = false;
/* Let's loop on the other devices as some may have the same vendor */
}
}
/* if we have a tab + a char, it means this is a product id
* but we only look at it if we own some pci devices of the current vendor*/
} else if ((line[0] == '\t') && (line[1] != '\t')
&& (skip_to_next_vendor == false)) {
/* the product name the second field */
strlcpy(product, skipspace(strstr(line, " ")),
PCI_PRODUCT_NAME_SIZE - 1);
remove_eol(product);
/* the product id is first field */
strlcpy(product_id, &line[1], 4);
product_id[4] = 0;
/* init sub_product and sub_vendor */
strlcpy(sub_product_id, "0000", 4);
strlcpy(sub_vendor_id, "0000", 4);
int_vendor_id = hex_to_int(vendor_id);
int_product_id = hex_to_int(product_id);
/* assign the product_name to any matching pci device */
for_each_pci_func(dev, domain) {
if (int_vendor_id == dev->vendor &&
int_product_id == dev->product) {
strlcpy(dev->dev_info->vendor_name, vendor,
PCI_VENDOR_NAME_SIZE - 1);
strlcpy(dev->dev_info->product_name, product,
PCI_PRODUCT_NAME_SIZE - 1);
}
}
/* if we have two tabs, it means this is a sub product
* but we only look at it if we own some pci devices of the current vendor*/
} else if ((line[0] == '\t') && (line[1] == '\t')
&& (skip_to_next_vendor == false)) {
/* the product name is last field */
strlcpy(product, skipspace(strstr(line, " ")),
PCI_PRODUCT_NAME_SIZE - 1);
strlcpy(product, skipspace(strstr(product, " ")),
PCI_PRODUCT_NAME_SIZE - 1);
remove_eol(product);
/* the sub_vendor id is first field */
strlcpy(sub_vendor_id, &line[2], 4);
sub_vendor_id[4] = 0;
/* the sub_vendor id is second field */
strlcpy(sub_product_id, &line[7], 4);
sub_product_id[4] = 0;
int_vendor_id = hex_to_int(vendor_id);
int_sub_vendor_id = hex_to_int(sub_vendor_id);
int_product_id = hex_to_int(product_id);
int_sub_product_id = hex_to_int(sub_product_id);
/* assign the product_name to any matching pci device */
for_each_pci_func(dev, domain) {
if (int_vendor_id == dev->vendor &&
int_product_id == dev->product &&
int_sub_product_id == dev->sub_product &&
int_sub_vendor_id == dev->sub_vendor) {
strlcpy(dev->dev_info->vendor_name, vendor,
PCI_VENDOR_NAME_SIZE - 1);
strlcpy(dev->dev_info->product_name, product,
PCI_PRODUCT_NAME_SIZE - 1);
}
}
}
}
fclose(f);
return 0;
}
/* searching if any pcidevice match our query */
struct match *find_pci_device(const struct pci_domain *domain,
struct match *list)
{
uint32_t did, sid;
struct match *m;
const struct pci_device *dev;
/* for all matches we have to search */
for (m = list; m; m = m->next) {
/* for each pci device we know */
for_each_pci_func(dev, domain) {
/* sid & did are the easiest way to compare devices */
/* they are made of vendor/product subvendor/subproduct ids */
sid = dev->svid_sdid;
did = dev->vid_did;
/* if the current device match */
if (((did ^ m->did) & m->did_mask) == 0 &&
((sid ^ m->sid) & m->sid_mask) == 0 &&
dev->revision >= m->rid_min && dev->revision <= m->rid_max) {
dprintf
("PCI Match: Vendor=%04x Product=%04x Sub_vendor=%04x Sub_Product=%04x Release=%02x\n",
dev->vendor, dev->product, dev->sub_vendor,
dev->sub_product, dev->revision);
/* returning the matched pci device */
return m;
}
}
}
return NULL;
}
/* scanning the pci bus to find pci devices */
struct pci_domain *pci_scan(void)
{
struct pci_domain *domain = NULL;
struct pci_bus *bus = NULL;
struct pci_slot *slot = NULL;
struct pci_device *func = NULL;
unsigned int nbus, ndev, nfunc, maxfunc;
uint32_t did, sid, rcid;
uint8_t hdrtype;
pciaddr_t a;
int cfgtype;
cfgtype = pci_set_config_type(PCI_CFG_AUTO);
dprintf("PCI configuration type %d\n", cfgtype);
if (cfgtype == PCI_CFG_NONE)
return NULL;
dprintf("Scanning PCI Buses\n");
for (nbus = 0; nbus < MAX_PCI_BUSES; nbus++) {
dprintf("Probing bus 0x%02x... \n", nbus);
bus = NULL;
for (ndev = 0; ndev < MAX_PCI_DEVICES; ndev++) {
maxfunc = 1; /* Assume a single-function device */
slot = NULL;
for (nfunc = 0; nfunc < maxfunc; nfunc++) {
a = pci_mkaddr(nbus, ndev, nfunc, 0);
did = pci_readl(a);
if (did == 0xffffffff || did == 0xffff0000 ||
did == 0x0000ffff || did == 0x00000000)
continue;
hdrtype = pci_readb(a + 0x0e);
if (hdrtype & 0x80)
maxfunc = MAX_PCI_FUNC; /* Multifunction device */
rcid = pci_readl(a + 0x08);
sid = pci_readl(a + 0x2c);
if (!domain) {
domain = zalloc(sizeof *domain);
if (!domain)
goto bail;
}
if (!bus) {
bus = zalloc(sizeof *bus);
if (!bus)
goto bail;
domain->bus[nbus] = bus;
}
if (!slot) {
slot = zalloc(sizeof *slot);
if (!slot)
goto bail;
bus->slot[ndev] = slot;
}
func = zalloc(sizeof *func);
if (!func)
goto bail;
slot->func[nfunc] = func;
func->vid_did = did;
func->svid_sdid = sid;
func->rid_class = rcid;
dprintf
("Scanning: BUS %02x DID %08x (%04x:%04x) SID %08x RID %02x\n",
nbus, did, did >> 16, (did << 16) >> 16, sid, rcid & 0xff);
}
}
}
return domain;
bail:
free_pci_domain(domain);
return NULL;
}
/* gathering additional configuration*/
void gather_additional_pci_config(struct pci_domain *domain)
{
struct pci_device *dev;
pciaddr_t pci_addr;
int cfgtype;
cfgtype = pci_set_config_type(PCI_CFG_AUTO);
if (cfgtype == PCI_CFG_NONE)
return;
for_each_pci_func3(dev, domain, pci_addr) {
if (!dev->dev_info) {
dev->dev_info = zalloc(sizeof *dev->dev_info);
if (!dev->dev_info) {
return;
}
}
dev->dev_info->irq = pci_readb(pci_addr + 0x3c);
dev->dev_info->latency = pci_readb(pci_addr + 0x0d);
}
}
void free_pci_domain(struct pci_domain *domain)
{
struct pci_bus *bus;
struct pci_slot *slot;
struct pci_device *func;
unsigned int nbus, ndev, nfunc;
if (domain) {
for (nbus = 0; nbus < MAX_PCI_BUSES; nbus++) {
bus = domain->bus[nbus];
if (bus) {
for (ndev = 0; ndev < MAX_PCI_DEVICES; ndev++) {
slot = bus->slot[ndev];
if (slot) {
for (nfunc = 0; nfunc < MAX_PCI_FUNC; nfunc++) {
func = slot->func[nfunc];
if (func) {
if (func->dev_info)
free(func->dev_info);
free(func);
}
free(slot);
}
}
free(bus);
}
}
free(domain);
}
}
}
/* Try to match any pci device to the appropriate kernel module */
/* it uses the modules.alias from the boot device */
int get_module_name_from_alias(struct pci_domain *domain, char *modules_alias_path)
{
char line[MAX_LINE];
char module_name[21]; // the module name field is 21 char long
char delims[]="*"; // colums are separated by spaces
char vendor_id[16];
char product_id[16];
char sub_vendor_id[16];
char sub_product_id[16];
FILE *f;
struct pci_device *dev=NULL;
/* Intializing the linux_kernel_module for each pci device to "unknown" */
/* adding a dev_info member if needed */
for_each_pci_func(dev, domain) {
/* initialize the dev_info structure if it doesn't exist yet. */
if (! dev->dev_info) {
dev->dev_info = zalloc(sizeof *dev->dev_info);
if (!dev->dev_info)
return -1;
}
for (int i=0;i<MAX_KERNEL_MODULES_PER_PCI_DEVICE;i++) {
if (strlen(dev->dev_info->linux_kernel_module[i])==0)
strlcpy(dev->dev_info->linux_kernel_module[i], "unknown",7);
}
}
/* Opening the modules.pcimap (of a linux kernel) from the boot device */
f=zfopen(modules_alias_path, "r");
if (!f)
return -ENOMODULESALIAS;
/* for each line we found in the modules.pcimap */
while ( fgets(line, sizeof line, f) ) {
/* skipping unecessary lines */
if ((line[0] == '#') || (strstr(line,"alias pci:v")==NULL))
continue;
/* Resetting temp buffer*/
memset(module_name,0,sizeof(module_name));
memset(vendor_id,0,sizeof(vendor_id));
memset(sub_vendor_id,0,sizeof(sub_vendor_id));
memset(product_id,0,sizeof(product_id));
memset(sub_product_id,0,sizeof(sub_product_id));
strcpy(vendor_id,"0000");
strcpy(product_id,"0000");
/* ffff will be used to match any device as in modules.alias
* a missing subvendor/product have to be considered as 0xFFFF*/
strcpy(sub_product_id,"ffff");
strcpy(sub_vendor_id,"ffff");
char *result = NULL;
int field=0;
/* looking for the next field */
result = strtok(line+strlen("alias pci:v"), delims);
while( result != NULL ) {
if (field==0) {
/* Searching for the vendor separator*/
char *temp = strstr(result,"d");
if (temp != NULL) {
strlcpy(vendor_id,result,temp-result);
result+=strlen(vendor_id)+1;
}
/* Searching for the product separator*/
temp = strstr(result,"sv");
if (temp != NULL) {
strlcpy(product_id,result,temp-result);
result+=strlen(product_id)+1;
}
/* Searching for the sub vendor separator*/
temp = strstr(result,"sd");
if (temp != NULL) {
strlcpy(sub_vendor_id,result,temp-result);
result+=strlen(sub_vendor_id)+1;
}
/* Searching for the sub product separator*/
temp = strstr(result,"bc");
if (temp != NULL) {
strlcpy(sub_product_id,result,temp-result);
result+=strlen(sub_product_id)+1;
}
/* That's the module name */
} else if ((strlen(result)>2) &&
(result[0]==0x20))
strcpy(module_name,result+1);
/* We have to replace \n by \0*/
module_name[strlen(module_name)-1]='\0';
field++;
/* Searching the next field */
result = strtok( NULL, delims );
}
/* Now we have extracted informations from the modules.alias
* Let's compare it with the devices we know*/
int int_vendor_id=hex_to_int(vendor_id);
int int_sub_vendor_id=hex_to_int(sub_vendor_id);
int int_product_id=hex_to_int(product_id);
int int_sub_product_id=hex_to_int(sub_product_id);
/* if a pci_device matches an entry, fill the linux_kernel_module with
the appropriate kernel module */
for_each_pci_func(dev, domain) {
if (int_vendor_id == dev->vendor &&
int_product_id == dev->product &&
(int_sub_product_id & dev->sub_product)
== dev->sub_product &&
(int_sub_vendor_id & dev->sub_vendor)
== dev->sub_vendor) {
bool found=false;
/* Scan all known kernel modules for this pci device */
for (int i=0; i<dev->dev_info->linux_kernel_module_count; i++) {
/* Try to detect if we already knew the same kernel module*/
if (strstr(dev->dev_info->linux_kernel_module[i], module_name)) {
found=true;
break;
}
}
/* If we don't have this kernel module, let's add it */
if (!found) {
strcpy(dev->dev_info->linux_kernel_module[dev->dev_info->linux_kernel_module_count], module_name);
dev->dev_info->linux_kernel_module_count++;
}
}
}
}
fclose(f);
return 0;
}