Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 911e1c9b05a8e3559a7aa89083930700a0b9e7ee

Authored by Narendra K 2010-07-26 18:56:50 +0800

Committed by Jesse Barnes 2010-07-31 00:36:01 +0800

Exists in master and in 7 other branches

PCI: export SMBIOS provided firmware instance and label to sysfs

This patch exports SMBIOS provided firmware instance and label of
onboard PCI devices to sysfs.  New files are:
  /sys/bus/pci/devices/.../label which contains the firmware name for
the device in question, and
  /sys/bus/pci/devices/.../index which contains the firmware device type
instance for the given device.

Signed-off-by: Jordan Hargrave <jordan_hargrave@dell.com>
Signed-off-by: Narendra K <narendra_k@dell.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>

Showing 7 changed files with 221 additions and 0 deletions Inline Diff

Documentation/ABI/testing/sysfs-bus-pci
drivers/firmware/dmi_scan.c
drivers/pci/Makefile
drivers/pci/pci-label.c
drivers/pci/pci-sysfs.c
drivers/pci/pci.h
include/linux/dmi.h

Documentation/ABI/testing/sysfs-bus-pci

Diff comments View file @ 911e1c9

 What:		/sys/bus/pci/drivers/.../bind
 Date:		December 2003
 Contact:	linux-pci@vger.kernel.org
 Description:
 		Writing a device location to this file will cause
 		the driver to attempt to bind to the device found at
 		this location.	This is useful for overriding default
 		bindings.  The format for the location is: DDDD:BB:DD.F.
 		That is Domain:Bus:Device.Function and is the same as
 		found in /sys/bus/pci/devices/.  For example:
 		# echo 0000:00:19.0 > /sys/bus/pci/drivers/foo/bind
 		(Note: kernels before 2.6.28 may require echo -n).
 What:		/sys/bus/pci/drivers/.../unbind
 Date:		December 2003
 Contact:	linux-pci@vger.kernel.org
 Description:
 		Writing a device location to this file will cause the
 		driver to attempt to unbind from the device found at
 		this location.	This may be useful when overriding default
 		bindings.  The format for the location is: DDDD:BB:DD.F.
 		That is Domain:Bus:Device.Function and is the same as
 		found in /sys/bus/pci/devices/. For example:
 		# echo 0000:00:19.0 > /sys/bus/pci/drivers/foo/unbind
 		(Note: kernels before 2.6.28 may require echo -n).
 What:		/sys/bus/pci/drivers/.../new_id
 Date:		December 2003
 Contact:	linux-pci@vger.kernel.org
 Description:
 		Writing a device ID to this file will attempt to
 		dynamically add a new device ID to a PCI device driver.
 		This may allow the driver to support more hardware than
 		was included in the driver's static device ID support
 		table at compile time.  The format for the device ID is:
 		VVVV DDDD SVVV SDDD CCCC MMMM PPPP.  That is Vendor ID,
 		Device ID, Subsystem Vendor ID, Subsystem Device ID,
 		Class, Class Mask, and Private Driver Data.  The Vendor ID
 		and Device ID fields are required, the rest are optional.
 		Upon successfully adding an ID, the driver will probe
 		for the device and attempt to bind to it.  For example:
 		# echo "8086 10f5" > /sys/bus/pci/drivers/foo/new_id
 What:		/sys/bus/pci/drivers/.../remove_id
 Date:		February 2009
 Contact:	Chris Wright <chrisw@sous-sol.org>
 Description:
 		Writing a device ID to this file will remove an ID
 		that was dynamically added via the new_id sysfs entry.
 		The format for the device ID is:
 		VVVV DDDD SVVV SDDD CCCC MMMM.	That is Vendor ID, Device
 		ID, Subsystem Vendor ID, Subsystem Device ID, Class,
 		and Class Mask.  The Vendor ID and Device ID fields are
 		required, the rest are optional.  After successfully
 		removing an ID, the driver will no longer support the
 		device.  This is useful to ensure auto probing won't
 		match the driver to the device.  For example:
 		# echo "8086 10f5" > /sys/bus/pci/drivers/foo/remove_id
 What:		/sys/bus/pci/rescan
 Date:		January 2009
 Contact:	Linux PCI developers <linux-pci@vger.kernel.org>
 Description:
 		Writing a non-zero value to this attribute will
 		force a rescan of all PCI buses in the system, and
 		re-discover previously removed devices.
 		Depends on CONFIG_HOTPLUG.
 What:		/sys/bus/pci/devices/.../remove
 Date:		January 2009
 Contact:	Linux PCI developers <linux-pci@vger.kernel.org>
 Description:
 		Writing a non-zero value to this attribute will
 		hot-remove the PCI device and any of its children.
 		Depends on CONFIG_HOTPLUG.
 What:		/sys/bus/pci/devices/.../rescan
 Date:		January 2009
 Contact:	Linux PCI developers <linux-pci@vger.kernel.org>
 Description:
 		Writing a non-zero value to this attribute will
 		force a rescan of the device's parent bus and all
 		child buses, and re-discover devices removed earlier
 		from this part of the device tree.
 		Depends on CONFIG_HOTPLUG.
 What:		/sys/bus/pci/devices/.../reset
 Date:		July 2009
 Contact:	Michael S. Tsirkin <mst@redhat.com>
 Description:
 		Some devices allow an individual function to be reset
 		without affecting other functions in the same device.
 		For devices that have this support, a file named reset
 		will be present in sysfs.  Writing 1 to this file
 		will perform reset.
 What:		/sys/bus/pci/devices/.../vpd
 Date:		February 2008
 Contact:	Ben Hutchings <bhutchings@solarflare.com>
 Description:
 		A file named vpd in a device directory will be a
 		binary file containing the Vital Product Data for the
 		device.  It should follow the VPD format defined in
 		PCI Specification 2.1 or 2.2, but users should consider
 		that some devices may have malformatted data.  If the
 		underlying VPD has a writable section then the
 		corresponding section of this file will be writable.
 What:		/sys/bus/pci/devices/.../virtfnN
 Date:		March 2009
 Contact:	Yu Zhao <yu.zhao@intel.com>
 Description:
 		This symbolic link appears when hardware supports the SR-IOV
 		capability and the Physical Function driver has enabled it.
 		The symbolic link points to the PCI device sysfs entry of the
 		Virtual Function whose index is N (0...MaxVFs-1).
 What:		/sys/bus/pci/devices/.../dep_link
 Date:		March 2009
 Contact:	Yu Zhao <yu.zhao@intel.com>
 Description:
 		This symbolic link appears when hardware supports the SR-IOV
 		capability and the Physical Function driver has enabled it,
 		and this device has vendor specific dependencies with others.
 		The symbolic link points to the PCI device sysfs entry of
 		Physical Function this device depends on.
 What:		/sys/bus/pci/devices/.../physfn
 Date:		March 2009
 Contact:	Yu Zhao <yu.zhao@intel.com>
 Description:
 		This symbolic link appears when a device is a Virtual Function.
 		The symbolic link points to the PCI device sysfs entry of the
 		Physical Function this device associates with.
 What:		/sys/bus/pci/slots/.../module
 Date:		June 2009
 Contact:	linux-pci@vger.kernel.org
 Description:
 		This symbolic link points to the PCI hotplug controller driver
 		module that manages the hotplug slot.
+What:		/sys/bus/pci/devices/.../label
+Date:		July 2010
+Contact:	Narendra K <narendra_k@dell.com>, linux-bugs@dell.com
+Description:
+		Reading this attribute will provide the firmware
+		given name(SMBIOS type 41 string) of the PCI device.
+		The attribute will be created only if the firmware
+		has given a name to the PCI device.
+Users:
+		Userspace applications interested in knowing the
+		firmware assigned name of the PCI device.
+What:		/sys/bus/pci/devices/.../index
+Date:		July 2010
+Contact:	Narendra K <narendra_k@dell.com>, linux-bugs@dell.com
+Description:
+		Reading this attribute will provide the firmware
+		given instance(SMBIOS type 41 device type instance)
+		of the PCI device. The attribute will be created
+		only if the firmware has given a device type instance
+		to the PCI device.
+Users:
+		Userspace applications interested in knowing the
+		firmware assigned device type instance of the PCI
+		device that can help in understanding the firmware
+		intended order of the PCI device.

drivers/firmware/dmi_scan.c

Diff comments View file @ 911e1c9

 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/dmi.h>
 #include <linux/efi.h>
 #include <linux/bootmem.h>
 #include <asm/dmi.h>
 /*
  * DMI stands for "Desktop Management Interface".  It is part
  * of and an antecedent to, SMBIOS, which stands for System
  * Management BIOS.  See further: http://www.dmtf.org/standards
  */
 static char dmi_empty_string[] = "        ";
 /*
  * Catch too early calls to dmi_check_system():
  */
 static int dmi_initialized;
 static const char * __init dmi_string_nosave(const struct dmi_header *dm, u8 s)
 {
 	const u8 *bp = ((u8 *) dm) + dm->length;
 	if (s) {
 		s--;
 		while (s > 0 && *bp) {
 			bp += strlen(bp) + 1;
 			s--;
 		}
 		if (*bp != 0) {
 			size_t len = strlen(bp)+1;
 			size_t cmp_len = len > 8 ? 8 : len;
 			if (!memcmp(bp, dmi_empty_string, cmp_len))
 				return dmi_empty_string;
 			return bp;
 		}
 	}
 	return "";
 }
 static char * __init dmi_string(const struct dmi_header *dm, u8 s)
 {
 	const char *bp = dmi_string_nosave(dm, s);
 	char *str;
 	size_t len;
 	if (bp == dmi_empty_string)
 		return dmi_empty_string;
 	len = strlen(bp) + 1;
 	str = dmi_alloc(len);
 	if (str != NULL)
 		strcpy(str, bp);
 	else
 		printk(KERN_ERR "dmi_string: cannot allocate %Zu bytes.\n", len);
 	return str;
 }
 /*
  *	We have to be cautious here. We have seen BIOSes with DMI pointers
  *	pointing to completely the wrong place for example
  */
 static void dmi_table(u8 *buf, int len, int num,
 		      void (*decode)(const struct dmi_header *, void *),
 		      void *private_data)
 {
 	u8 *data = buf;
 	int i = 0;
 	/*
 	 *	Stop when we see all the items the table claimed to have
 	 *	OR we run off the end of the table (also happens)
 	 */
 	while ((i < num) && (data - buf + sizeof(struct dmi_header)) <= len) {
 		const struct dmi_header *dm = (const struct dmi_header *)data;
 		/*
 		 *  We want to know the total length (formatted area and
 		 *  strings) before decoding to make sure we won't run off the
 		 *  table in dmi_decode or dmi_string
 		 */
 		data += dm->length;
 		while ((data - buf < len - 1) && (data[0] || data[1]))
 			data++;
 		if (data - buf < len - 1)
 			decode(dm, private_data);
 		data += 2;
 		i++;
 	}
 }
 static u32 dmi_base;
 static u16 dmi_len;
 static u16 dmi_num;
 static int __init dmi_walk_early(void (*decode)(const struct dmi_header *,
 		void *))
 {
 	u8 *buf;
 	buf = dmi_ioremap(dmi_base, dmi_len);
 	if (buf == NULL)
 		return -1;
 	dmi_table(buf, dmi_len, dmi_num, decode, NULL);
 	dmi_iounmap(buf, dmi_len);
 	return 0;
 }
 static int __init dmi_checksum(const u8 *buf)
 {
 	u8 sum = 0;
 	int a;
 	for (a = 0; a < 15; a++)
 		sum += buf[a];
 	return sum == 0;
 }
 static char *dmi_ident[DMI_STRING_MAX];
 static LIST_HEAD(dmi_devices);
 int dmi_available;
 /*
  *	Save a DMI string
  */
 static void __init dmi_save_ident(const struct dmi_header *dm, int slot, int string)
 {
 	const char *d = (const char*) dm;
 	char *p;
 	if (dmi_ident[slot])
 		return;
 	p = dmi_string(dm, d[string]);
 	if (p == NULL)
 		return;
 	dmi_ident[slot] = p;
 }
 static void __init dmi_save_uuid(const struct dmi_header *dm, int slot, int index)
 {
 	const u8 *d = (u8*) dm + index;
 	char *s;
 	int is_ff = 1, is_00 = 1, i;
 	if (dmi_ident[slot])
 		return;
 	for (i = 0; i < 16 && (is_ff || is_00); i++) {
 		if(d[i] != 0x00) is_ff = 0;
 		if(d[i] != 0xFF) is_00 = 0;
 	}
 	if (is_ff || is_00)
 		return;
 	s = dmi_alloc(16*2+4+1);
 	if (!s)
 		return;
 	sprintf(s, "%pUB", d);
         dmi_ident[slot] = s;
 }
 static void __init dmi_save_type(const struct dmi_header *dm, int slot, int index)
 {
 	const u8 *d = (u8*) dm + index;
 	char *s;
 	if (dmi_ident[slot])
 		return;
 	s = dmi_alloc(4);
 	if (!s)
 		return;
 	sprintf(s, "%u", *d & 0x7F);
 	dmi_ident[slot] = s;
 }
 static void __init dmi_save_one_device(int type, const char *name)
 {
 	struct dmi_device *dev;
 	/* No duplicate device */
 	if (dmi_find_device(type, name, NULL))
 		return;
 	dev = dmi_alloc(sizeof(*dev) + strlen(name) + 1);
 	if (!dev) {
 		printk(KERN_ERR "dmi_save_one_device: out of memory.\n");
 		return;
 	}
 	dev->type = type;
 	strcpy((char *)(dev + 1), name);
 	dev->name = (char *)(dev + 1);
 	dev->device_data = NULL;
 	list_add(&dev->list, &dmi_devices);
 }
 static void __init dmi_save_devices(const struct dmi_header *dm)
 {
 	int i, count = (dm->length - sizeof(struct dmi_header)) / 2;
 	for (i = 0; i < count; i++) {
 		const char *d = (char *)(dm + 1) + (i * 2);
 		/* Skip disabled device */
 		if ((*d & 0x80) == 0)
 			continue;
 		dmi_save_one_device(*d & 0x7f, dmi_string_nosave(dm, *(d + 1)));
 	}
 }
 static void __init dmi_save_oem_strings_devices(const struct dmi_header *dm)
 {
 	int i, count = *(u8 *)(dm + 1);
 	struct dmi_device *dev;
 	for (i = 1; i <= count; i++) {
 		char *devname = dmi_string(dm, i);
 		if (devname == dmi_empty_string)
 			continue;
 		dev = dmi_alloc(sizeof(*dev));
 		if (!dev) {
 			printk(KERN_ERR
 			   "dmi_save_oem_strings_devices: out of memory.\n");
 			break;
 		}
 		dev->type = DMI_DEV_TYPE_OEM_STRING;
 		dev->name = devname;
 		dev->device_data = NULL;
 		list_add(&dev->list, &dmi_devices);
 	}
 }
 static void __init dmi_save_ipmi_device(const struct dmi_header *dm)
 {
 	struct dmi_device *dev;
 	void * data;
 	data = dmi_alloc(dm->length);
 	if (data == NULL) {
 		printk(KERN_ERR "dmi_save_ipmi_device: out of memory.\n");
 		return;
 	}
 	memcpy(data, dm, dm->length);
 	dev = dmi_alloc(sizeof(*dev));
 	if (!dev) {
 		printk(KERN_ERR "dmi_save_ipmi_device: out of memory.\n");
 		return;
 	}
 	dev->type = DMI_DEV_TYPE_IPMI;
 	dev->name = "IPMI controller";
 	dev->device_data = data;
 	list_add_tail(&dev->list, &dmi_devices);
 }
+static void __init dmi_save_dev_onboard(int instance, int segment, int bus,
+					int devfn, const char *name)
+{
+	struct dmi_dev_onboard *onboard_dev;
+	onboard_dev = dmi_alloc(sizeof(*onboard_dev) + strlen(name) + 1);
+	if (!onboard_dev) {
+		printk(KERN_ERR "dmi_save_dev_onboard: out of memory.\n");
+		return;
+	}
+	onboard_dev->instance = instance;
+	onboard_dev->segment = segment;
+	onboard_dev->bus = bus;
+	onboard_dev->devfn = devfn;
+	strcpy((char *)&onboard_dev[1], name);
+	onboard_dev->dev.type = DMI_DEV_TYPE_DEV_ONBOARD;
+	onboard_dev->dev.name = (char *)&onboard_dev[1];
+	onboard_dev->dev.device_data = onboard_dev;
+	list_add(&onboard_dev->dev.list, &dmi_devices);
+}
 static void __init dmi_save_extended_devices(const struct dmi_header *dm)
 {
 	const u8 *d = (u8*) dm + 5;
 	/* Skip disabled device */
 	if ((*d & 0x80) == 0)
 		return;
+	dmi_save_dev_onboard(*(d+1), *(u16 *)(d+2), *(d+4), *(d+5),
+			     dmi_string_nosave(dm, *(d-1)));
 	dmi_save_one_device(*d & 0x7f, dmi_string_nosave(dm, *(d - 1)));
 }
 /*
  *	Process a DMI table entry. Right now all we care about are the BIOS
  *	and machine entries. For 2.5 we should pull the smbus controller info
  *	out of here.
  */
 static void __init dmi_decode(const struct dmi_header *dm, void *dummy)
 {
 	switch(dm->type) {
 	case 0:		/* BIOS Information */
 		dmi_save_ident(dm, DMI_BIOS_VENDOR, 4);
 		dmi_save_ident(dm, DMI_BIOS_VERSION, 5);
 		dmi_save_ident(dm, DMI_BIOS_DATE, 8);
 		break;
 	case 1:		/* System Information */
 		dmi_save_ident(dm, DMI_SYS_VENDOR, 4);
 		dmi_save_ident(dm, DMI_PRODUCT_NAME, 5);
 		dmi_save_ident(dm, DMI_PRODUCT_VERSION, 6);
 		dmi_save_ident(dm, DMI_PRODUCT_SERIAL, 7);
 		dmi_save_uuid(dm, DMI_PRODUCT_UUID, 8);
 		break;
 	case 2:		/* Base Board Information */
 		dmi_save_ident(dm, DMI_BOARD_VENDOR, 4);
 		dmi_save_ident(dm, DMI_BOARD_NAME, 5);
 		dmi_save_ident(dm, DMI_BOARD_VERSION, 6);
 		dmi_save_ident(dm, DMI_BOARD_SERIAL, 7);
 		dmi_save_ident(dm, DMI_BOARD_ASSET_TAG, 8);
 		break;
 	case 3:		/* Chassis Information */
 		dmi_save_ident(dm, DMI_CHASSIS_VENDOR, 4);
 		dmi_save_type(dm, DMI_CHASSIS_TYPE, 5);
 		dmi_save_ident(dm, DMI_CHASSIS_VERSION, 6);
 		dmi_save_ident(dm, DMI_CHASSIS_SERIAL, 7);
 		dmi_save_ident(dm, DMI_CHASSIS_ASSET_TAG, 8);
 		break;
 	case 10:	/* Onboard Devices Information */
 		dmi_save_devices(dm);
 		break;
 	case 11:	/* OEM Strings */
 		dmi_save_oem_strings_devices(dm);
 		break;
 	case 38:	/* IPMI Device Information */
 		dmi_save_ipmi_device(dm);
 		break;
 	case 41:	/* Onboard Devices Extended Information */
 		dmi_save_extended_devices(dm);
 	}
 }
 static int __init dmi_present(const char __iomem *p)
 {
 	u8 buf[15];
 	memcpy_fromio(buf, p, 15);
 	if ((memcmp(buf, "_DMI_", 5) == 0) && dmi_checksum(buf)) {
 		dmi_num = (buf[13] << 8) | buf[12];
 		dmi_len = (buf[7] << 8) | buf[6];
 		dmi_base = (buf[11] << 24) | (buf[10] << 16) |
 			(buf[9] << 8) | buf[8];
 		/*
 		 * DMI version 0.0 means that the real version is taken from
 		 * the SMBIOS version, which we don't know at this point.
 		 */
 		if (buf[14] != 0)
 			printk(KERN_INFO "DMI %d.%d present.\n",
 			       buf[14] >> 4, buf[14] & 0xF);
 		else
 			printk(KERN_INFO "DMI present.\n");
 		if (dmi_walk_early(dmi_decode) == 0)
 			return 0;
 	}
 	return 1;
 }
 void __init dmi_scan_machine(void)
 {
 	char __iomem *p, *q;
 	int rc;
 	if (efi_enabled) {
 		if (efi.smbios == EFI_INVALID_TABLE_ADDR)
 			goto error;
 		/* This is called as a core_initcall() because it isn't
 		 * needed during early boot.  This also means we can
 		 * iounmap the space when we're done with it.
 		 */
 		p = dmi_ioremap(efi.smbios, 32);
 		if (p == NULL)
 			goto error;
 		rc = dmi_present(p + 0x10); /* offset of _DMI_ string */
 		dmi_iounmap(p, 32);
 		if (!rc) {
 			dmi_available = 1;
 			goto out;
 		}
 	}
 	else {
 		/*
 		 * no iounmap() for that ioremap(); it would be a no-op, but
 		 * it's so early in setup that sucker gets confused into doing
 		 * what it shouldn't if we actually call it.
 		 */
 		p = dmi_ioremap(0xF0000, 0x10000);
 		if (p == NULL)
 			goto error;
 		for (q = p; q < p + 0x10000; q += 16) {
 			rc = dmi_present(q);
 			if (!rc) {
 				dmi_available = 1;
 				dmi_iounmap(p, 0x10000);
 				goto out;
 			}
 		}
 		dmi_iounmap(p, 0x10000);
 	}
  error:
 	printk(KERN_INFO "DMI not present or invalid.\n");
  out:
 	dmi_initialized = 1;
 }
 /**
  *	dmi_matches - check if dmi_system_id structure matches system DMI data
  *	@dmi: pointer to the dmi_system_id structure to check
  */
 static bool dmi_matches(const struct dmi_system_id *dmi)
 {
 	int i;
 	WARN(!dmi_initialized, KERN_ERR "dmi check: not initialized yet.\n");
 	for (i = 0; i < ARRAY_SIZE(dmi->matches); i++) {
 		int s = dmi->matches[i].slot;
 		if (s == DMI_NONE)
 			break;
 		if (dmi_ident[s]
 		    && strstr(dmi_ident[s], dmi->matches[i].substr))
 			continue;
 		/* No match */
 		return false;
 	}
 	return true;
 }
 /**
  *	dmi_is_end_of_table - check for end-of-table marker
  *	@dmi: pointer to the dmi_system_id structure to check
  */
 static bool dmi_is_end_of_table(const struct dmi_system_id *dmi)
 {
 	return dmi->matches[0].slot == DMI_NONE;
 }
 /**
  *	dmi_check_system - check system DMI data
  *	@list: array of dmi_system_id structures to match against
  *		All non-null elements of the list must match
  *		their slot's (field index's) data (i.e., each
  *		list string must be a substring of the specified
  *		DMI slot's string data) to be considered a
  *		successful match.
  *
  *	Walk the blacklist table running matching functions until someone
  *	returns non zero or we hit the end. Callback function is called for
  *	each successful match. Returns the number of matches.
  */
 int dmi_check_system(const struct dmi_system_id *list)
 {
 	int count = 0;
 	const struct dmi_system_id *d;
 	for (d = list; !dmi_is_end_of_table(d); d++)
 		if (dmi_matches(d)) {
 			count++;
 			if (d->callback && d->callback(d))
 				break;
 		}
 	return count;
 }
 EXPORT_SYMBOL(dmi_check_system);
 /**
  *	dmi_first_match - find dmi_system_id structure matching system DMI data
  *	@list: array of dmi_system_id structures to match against
  *		All non-null elements of the list must match
  *		their slot's (field index's) data (i.e., each
  *		list string must be a substring of the specified
  *		DMI slot's string data) to be considered a
  *		successful match.
  *
  *	Walk the blacklist table until the first match is found.  Return the
  *	pointer to the matching entry or NULL if there's no match.
  */
 const struct dmi_system_id *dmi_first_match(const struct dmi_system_id *list)
 {
 	const struct dmi_system_id *d;
 	for (d = list; !dmi_is_end_of_table(d); d++)
 		if (dmi_matches(d))
 			return d;
 	return NULL;
 }
 EXPORT_SYMBOL(dmi_first_match);
 /**
  *	dmi_get_system_info - return DMI data value
  *	@field: data index (see enum dmi_field)
  *
  *	Returns one DMI data value, can be used to perform
  *	complex DMI data checks.
  */
 const char *dmi_get_system_info(int field)
 {
 	return dmi_ident[field];
 }
 EXPORT_SYMBOL(dmi_get_system_info);
 /**
  * dmi_name_in_serial - Check if string is in the DMI product serial information
  * @str: string to check for
  */
 int dmi_name_in_serial(const char *str)
 {
 	int f = DMI_PRODUCT_SERIAL;
 	if (dmi_ident[f] && strstr(dmi_ident[f], str))
 		return 1;
 	return 0;
 }
 /**
  *	dmi_name_in_vendors - Check if string is anywhere in the DMI vendor information.
  *	@str: 	Case sensitive Name
  */
 int dmi_name_in_vendors(const char *str)
 {
 	static int fields[] = { DMI_BIOS_VENDOR, DMI_BIOS_VERSION, DMI_SYS_VENDOR,
 				DMI_PRODUCT_NAME, DMI_PRODUCT_VERSION, DMI_BOARD_VENDOR,
 				DMI_BOARD_NAME, DMI_BOARD_VERSION, DMI_NONE };
 	int i;
 	for (i = 0; fields[i] != DMI_NONE; i++) {
 		int f = fields[i];
 		if (dmi_ident[f] && strstr(dmi_ident[f], str))
 			return 1;
 	}
 	return 0;
 }
 EXPORT_SYMBOL(dmi_name_in_vendors);
 /**
  *	dmi_find_device - find onboard device by type/name
  *	@type: device type or %DMI_DEV_TYPE_ANY to match all device types
  *	@name: device name string or %NULL to match all
  *	@from: previous device found in search, or %NULL for new search.
  *
  *	Iterates through the list of known onboard devices. If a device is
  *	found with a matching @vendor and @device, a pointer to its device
  *	structure is returned.  Otherwise, %NULL is returned.
  *	A new search is initiated by passing %NULL as the @from argument.
  *	If @from is not %NULL, searches continue from next device.
  */
 const struct dmi_device * dmi_find_device(int type, const char *name,
 				    const struct dmi_device *from)
 {
 	const struct list_head *head = from ? &from->list : &dmi_devices;
 	struct list_head *d;
 	for(d = head->next; d != &dmi_devices; d = d->next) {
 		const struct dmi_device *dev =
 			list_entry(d, struct dmi_device, list);
 		if (((type == DMI_DEV_TYPE_ANY) || (dev->type == type)) &&
 		    ((name == NULL) || (strcmp(dev->name, name) == 0)))
 			return dev;
 	}
 	return NULL;
 }
 EXPORT_SYMBOL(dmi_find_device);
 /**
  *	dmi_get_date - parse a DMI date
  *	@field:	data index (see enum dmi_field)
  *	@yearp: optional out parameter for the year
  *	@monthp: optional out parameter for the month
  *	@dayp: optional out parameter for the day
  *
  *	The date field is assumed to be in the form resembling
  *	[mm[/dd]]/yy[yy] and the result is stored in the out
  *	parameters any or all of which can be omitted.
  *
  *	If the field doesn't exist, all out parameters are set to zero
  *	and false is returned.  Otherwise, true is returned with any
  *	invalid part of date set to zero.
  *
  *	On return, year, month and day are guaranteed to be in the
  *	range of [0,9999], [0,12] and [0,31] respectively.
  */
 bool dmi_get_date(int field, int *yearp, int *monthp, int *dayp)
 {
 	int year = 0, month = 0, day = 0;
 	bool exists;
 	const char *s, *y;
 	char *e;
 	s = dmi_get_system_info(field);
 	exists = s;
 	if (!exists)
 		goto out;
 	/*
 	 * Determine year first.  We assume the date string resembles
 	 * mm/dd/yy[yy] but the original code extracted only the year
 	 * from the end.  Keep the behavior in the spirit of no
 	 * surprises.
 	 */
 	y = strrchr(s, '/');
 	if (!y)
 		goto out;
 	y++;
 	year = simple_strtoul(y, &e, 10);
 	if (y != e && year < 100) {	/* 2-digit year */
 		year += 1900;
 		if (year < 1996)	/* no dates < spec 1.0 */
 			year += 100;
 	}
 	if (year > 9999)		/* year should fit in %04d */
 		year = 0;
 	/* parse the mm and dd */
 	month = simple_strtoul(s, &e, 10);
 	if (s == e || *e != '/' || !month || month > 12) {
 		month = 0;
 		goto out;
 	}
 	s = e + 1;
 	day = simple_strtoul(s, &e, 10);
 	if (s == y || s == e || *e != '/' || day > 31)
 		day = 0;
 out:
 	if (yearp)
 		*yearp = year;
 	if (monthp)
 		*monthp = month;
 	if (dayp)
 		*dayp = day;
 	return exists;
 }
 EXPORT_SYMBOL(dmi_get_date);
 /**
  *	dmi_walk - Walk the DMI table and get called back for every record
  *	@decode: Callback function
  *	@private_data: Private data to be passed to the callback function
  *
  *	Returns -1 when the DMI table can't be reached, 0 on success.
  */
 int dmi_walk(void (*decode)(const struct dmi_header *, void *),
 	     void *private_data)
 {
 	u8 *buf;
 	if (!dmi_available)
 		return -1;
 	buf = ioremap(dmi_base, dmi_len);
 	if (buf == NULL)
 		return -1;
 	dmi_table(buf, dmi_len, dmi_num, decode, private_data);
 	iounmap(buf);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(dmi_walk);
 /**
  * dmi_match - compare a string to the dmi field (if exists)
  * @f: DMI field identifier
  * @str: string to compare the DMI field to
  *
  * Returns true if the requested field equals to the str (including NULL).
  */
 bool dmi_match(enum dmi_field f, const char *str)
 {
 	const char *info = dmi_get_system_info(f);
 	if (info == NULL || str == NULL)
 		return info == str;
 	return !strcmp(info, str);
 }
 EXPORT_SYMBOL_GPL(dmi_match);

drivers/pci/Makefile

Diff comments View file @ 911e1c9

 #
 # Makefile for the PCI bus specific drivers.
 #
 obj-y		+= access.o bus.o probe.o remove.o pci.o \
 			pci-driver.o search.o pci-sysfs.o rom.o setup-res.o \
 			irq.o vpd.o
 obj-$(CONFIG_PROC_FS) += proc.o
 obj-$(CONFIG_SYSFS) += slot.o
 obj-$(CONFIG_PCI_QUIRKS) += quirks.o
 # Build PCI Express stuff if needed
 obj-$(CONFIG_PCIEPORTBUS) += pcie/
 obj-$(CONFIG_PCI_IOAPIC) += ioapic.o
 obj-$(CONFIG_HOTPLUG) += hotplug.o
 # Build the PCI Hotplug drivers if we were asked to
 obj-$(CONFIG_HOTPLUG_PCI) += hotplug/
 ifdef CONFIG_HOTPLUG_PCI
 obj-y += hotplug-pci.o
 endif
 # Build the PCI MSI interrupt support
 obj-$(CONFIG_PCI_MSI) += msi.o
 # Build the Hypertransport interrupt support
 obj-$(CONFIG_HT_IRQ) += htirq.o
 # Build Intel IOMMU support
 obj-$(CONFIG_DMAR) += dmar.o iova.o intel-iommu.o
 obj-$(CONFIG_INTR_REMAP) += dmar.o intr_remapping.o
 obj-$(CONFIG_PCI_IOV) += iov.o
 #
 # Some architectures use the generic PCI setup functions
 #
 obj-$(CONFIG_X86) += setup-bus.o
 obj-$(CONFIG_ALPHA) += setup-bus.o setup-irq.o
 obj-$(CONFIG_ARM) += setup-bus.o setup-irq.o
 obj-$(CONFIG_PARISC) += setup-bus.o
 obj-$(CONFIG_SUPERH) += setup-bus.o setup-irq.o
 obj-$(CONFIG_PPC) += setup-bus.o
 obj-$(CONFIG_MIPS) += setup-bus.o setup-irq.o
 obj-$(CONFIG_X86_VISWS) += setup-irq.o
 obj-$(CONFIG_MN10300) += setup-bus.o
 obj-$(CONFIG_MICROBLAZE) += setup-bus.o
 #
 # ACPI Related PCI FW Functions
 #
 obj-$(CONFIG_ACPI)    += pci-acpi.o
+# SMBIOS provided firmware instance and labels
+obj-$(CONFIG_DMI)    += pci-label.o
 # Cardbus & CompactPCI use setup-bus
 obj-$(CONFIG_HOTPLUG) += setup-bus.o
 obj-$(CONFIG_PCI_SYSCALL) += syscall.o
 obj-$(CONFIG_PCI_STUB) += pci-stub.o
 ifeq ($(CONFIG_PCI_DEBUG),y)
 EXTRA_CFLAGS += -DDEBUG
 endif

drivers/pci/pci-label.c

Diff comments View file @ 911e1c9

File was created	1	/*
	2	* Purpose: Export the firmware instance and label associated with
	3	* a pci device to sysfs
	4	* Copyright (C) 2010 Dell Inc.
	5	* by Narendra K <Narendra_K@dell.com>,
	6	* Jordan Hargrave <Jordan_Hargrave@dell.com>
	7	*
	8	* SMBIOS defines type 41 for onboard pci devices. This code retrieves
	9	* the instance number and string from the type 41 record and exports
	10	* it to sysfs.
	11	*
	12	* Please see http://linux.dell.com/wiki/index.php/Oss/libnetdevname for more
	13	* information.
	14	*/
	15
	16	#include <linux/dmi.h>
	17	#include <linux/sysfs.h>
	18	#include <linux/pci.h>
	19	#include <linux/pci_ids.h>
	20	#include <linux/module.h>
	21	#include <linux/device.h>
	22	#include "pci.h"
	23
	24	enum smbios_attr_enum {
	25	SMBIOS_ATTR_NONE = 0,
	26	SMBIOS_ATTR_LABEL_SHOW,
	27	SMBIOS_ATTR_INSTANCE_SHOW,
	28	};
	29
	30	static mode_t
	31	find_smbios_instance_string(struct pci_dev pdev, char buf,
	32	enum smbios_attr_enum attribute)
	33	{
	34	const struct dmi_device *dmi;
	35	struct dmi_dev_onboard *donboard;
	36	int bus;
	37	int devfn;
	38
	39	bus = pdev->bus->number;
	40	devfn = pdev->devfn;
	41
	42	dmi = NULL;
	43	while ((dmi = dmi_find_device(DMI_DEV_TYPE_DEV_ONBOARD,
	44	NULL, dmi)) != NULL) {
	45	donboard = dmi->device_data;
	46	if (donboard && donboard->bus == bus &&
	47	donboard->devfn == devfn) {
	48	if (buf) {
	49	if (attribute == SMBIOS_ATTR_INSTANCE_SHOW)
	50	return scnprintf(buf, PAGE_SIZE,
	51	"%d\n",
	52	donboard->instance);
	53	else if (attribute == SMBIOS_ATTR_LABEL_SHOW)
	54	return scnprintf(buf, PAGE_SIZE,
	55	"%s\n",
	56	dmi->name);
	57	}
	58	return strlen(dmi->name);
	59	}
	60	}
	61	return 0;
	62	}
	63
	64	static mode_t
	65	smbios_instance_string_exist(struct kobject kobj, struct attribute attr,
	66	int n)
	67	{
	68	struct device *dev;
	69	struct pci_dev *pdev;
	70
	71	dev = container_of(kobj, struct device, kobj);
	72	pdev = to_pci_dev(dev);
	73
	74	return find_smbios_instance_string(pdev, NULL, SMBIOS_ATTR_NONE) ?
	75	S_IRUGO : 0;
	76	}
	77
	78	static ssize_t
	79	smbioslabel_show(struct device dev, struct device_attribute attr, char *buf)
	80	{
	81	struct pci_dev *pdev;
	82	pdev = to_pci_dev(dev);
	83
	84	return find_smbios_instance_string(pdev, buf,
	85	SMBIOS_ATTR_LABEL_SHOW);
	86	}
	87
	88	static ssize_t
	89	smbiosinstance_show(struct device *dev,
	90	struct device_attribute attr, char buf)
	91	{
	92	struct pci_dev *pdev;
	93	pdev = to_pci_dev(dev);
	94
	95	return find_smbios_instance_string(pdev, buf,
	96	SMBIOS_ATTR_INSTANCE_SHOW);
	97	}
	98
	99	static struct device_attribute smbios_attr_label = {
	100	.attr = {.name = "label", .mode = 0444, .owner = THIS_MODULE},
	101	.show = smbioslabel_show,
	102	};
	103
	104	static struct device_attribute smbios_attr_instance = {
	105	.attr = {.name = "index", .mode = 0444, .owner = THIS_MODULE},
	106	.show = smbiosinstance_show,
	107	};
	108
	109	static struct attribute *smbios_attributes[] = {
	110	&smbios_attr_label.attr,
	111	&smbios_attr_instance.attr,
	112	NULL,
	113	};
	114
	115	static struct attribute_group smbios_attr_group = {
	116	.attrs = smbios_attributes,
	117	.is_visible = smbios_instance_string_exist,
	118	};
	119
	120	static int
	121	pci_create_smbiosname_file(struct pci_dev *pdev)
	122	{
	123	if (!sysfs_create_group(&pdev->dev.kobj, &smbios_attr_group))
	124	return 0;
	125	return -ENODEV;
	126	}
	127
	128	static void
	129	pci_remove_smbiosname_file(struct pci_dev *pdev)
	130	{
	131	sysfs_remove_group(&pdev->dev.kobj, &smbios_attr_group);
	132	}
	133
	134	void pci_create_firmware_label_files(struct pci_dev *pdev)
	135	{
	136	if (!pci_create_smbiosname_file(pdev))
	137	;
	138	}
	139
	140	void pci_remove_firmware_label_files(struct pci_dev *pdev)
	141	{
	142	pci_remove_smbiosname_file(pdev);
	143	}
	144

drivers/pci/pci-sysfs.c

Diff comments View file @ 911e1c9

 /*
  * drivers/pci/pci-sysfs.c
  *
  * (C) Copyright 2002-2004 Greg Kroah-Hartman <greg@kroah.com>
  * (C) Copyright 2002-2004 IBM Corp.
  * (C) Copyright 2003 Matthew Wilcox
  * (C) Copyright 2003 Hewlett-Packard
  * (C) Copyright 2004 Jon Smirl <jonsmirl@yahoo.com>
  * (C) Copyright 2004 Silicon Graphics, Inc. Jesse Barnes <jbarnes@sgi.com>
  *
  * File attributes for PCI devices
  *
  * Modeled after usb's driverfs.c
  *
  */
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/pci.h>
 #include <linux/stat.h>
 #include <linux/topology.h>
 #include <linux/mm.h>
 #include <linux/fs.h>
 #include <linux/capability.h>
 #include <linux/pci-aspm.h>
 #include <linux/slab.h>
 #include "pci.h"
 static int sysfs_initialized;	/* = 0 */
 /* show configuration fields */
 #define pci_config_attr(field, format_string)				\
 static ssize_t								\
 field##_show(struct device *dev, struct device_attribute *attr, char *buf)				\
 {									\
 	struct pci_dev *pdev;						\
 									\
 	pdev = to_pci_dev (dev);					\
 	return sprintf (buf, format_string, pdev->field);		\
 }
 pci_config_attr(vendor, "0x%04x\n");
 pci_config_attr(device, "0x%04x\n");
 pci_config_attr(subsystem_vendor, "0x%04x\n");
 pci_config_attr(subsystem_device, "0x%04x\n");
 pci_config_attr(class, "0x%06x\n");
 pci_config_attr(irq, "%u\n");
 static ssize_t broken_parity_status_show(struct device *dev,
 					 struct device_attribute *attr,
 					 char *buf)
 {
 	struct pci_dev *pdev = to_pci_dev(dev);
 	return sprintf (buf, "%u\n", pdev->broken_parity_status);
 }
 static ssize_t broken_parity_status_store(struct device *dev,
 					  struct device_attribute *attr,
 					  const char *buf, size_t count)
 {
 	struct pci_dev *pdev = to_pci_dev(dev);
 	unsigned long val;
 	if (strict_strtoul(buf, 0, &val) < 0)
 		return -EINVAL;
 	pdev->broken_parity_status = !!val;
 	return count;
 }
 static ssize_t local_cpus_show(struct device *dev,
 			struct device_attribute *attr, char *buf)
 {
 	const struct cpumask *mask;
 	int len;
 #ifdef CONFIG_NUMA
 	mask = (dev_to_node(dev) == -1) ? cpu_online_mask :
 					  cpumask_of_node(dev_to_node(dev));
 #else
 	mask = cpumask_of_pcibus(to_pci_dev(dev)->bus);
 #endif
 	len = cpumask_scnprintf(buf, PAGE_SIZE-2, mask);
 	buf[len++] = '\n';
 	buf[len] = '\0';
 	return len;
 }
 static ssize_t local_cpulist_show(struct device *dev,
 			struct device_attribute *attr, char *buf)
 {
 	const struct cpumask *mask;
 	int len;
 #ifdef CONFIG_NUMA
 	mask = (dev_to_node(dev) == -1) ? cpu_online_mask :
 					  cpumask_of_node(dev_to_node(dev));
 #else
 	mask = cpumask_of_pcibus(to_pci_dev(dev)->bus);
 #endif
 	len = cpulist_scnprintf(buf, PAGE_SIZE-2, mask);
 	buf[len++] = '\n';
 	buf[len] = '\0';
 	return len;
 }
 /* show resources */
 static ssize_t
 resource_show(struct device * dev, struct device_attribute *attr, char * buf)
 {
 	struct pci_dev * pci_dev = to_pci_dev(dev);
 	char * str = buf;
 	int i;
 	int max;
 	resource_size_t start, end;
 	if (pci_dev->subordinate)
 		max = DEVICE_COUNT_RESOURCE;
 	else
 		max = PCI_BRIDGE_RESOURCES;
 	for (i = 0; i < max; i++) {
 		struct resource *res =  &pci_dev->resource[i];
 		pci_resource_to_user(pci_dev, i, res, &start, &end);
 		str += sprintf(str,"0x%016llx 0x%016llx 0x%016llx\n",
 			       (unsigned long long)start,
 			       (unsigned long long)end,
 			       (unsigned long long)res->flags);
 	}
 	return (str - buf);
 }
 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct pci_dev *pci_dev = to_pci_dev(dev);
 	return sprintf(buf, "pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x\n",
 		       pci_dev->vendor, pci_dev->device,
 		       pci_dev->subsystem_vendor, pci_dev->subsystem_device,
 		       (u8)(pci_dev->class >> 16), (u8)(pci_dev->class >> 8),
 		       (u8)(pci_dev->class));
 }
 static ssize_t is_enabled_store(struct device *dev,
 				struct device_attribute *attr, const char *buf,
 				size_t count)
 {
 	struct pci_dev *pdev = to_pci_dev(dev);
 	unsigned long val;
 	ssize_t result = strict_strtoul(buf, 0, &val);
 	if (result < 0)
 		return result;
 	/* this can crash the machine when done on the "wrong" device */
 	if (!capable(CAP_SYS_ADMIN))
 		return -EPERM;
 	if (!val) {
 		if (pci_is_enabled(pdev))
 			pci_disable_device(pdev);
 		else
 			result = -EIO;
 	} else
 		result = pci_enable_device(pdev);
 	return result < 0 ? result : count;
 }
 static ssize_t is_enabled_show(struct device *dev,
 			       struct device_attribute *attr, char *buf)
 {
 	struct pci_dev *pdev;
 	pdev = to_pci_dev (dev);
 	return sprintf (buf, "%u\n", atomic_read(&pdev->enable_cnt));
 }
 #ifdef CONFIG_NUMA
 static ssize_t
 numa_node_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	return sprintf (buf, "%d\n", dev->numa_node);
 }
 #endif
 static ssize_t
 dma_mask_bits_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct pci_dev *pdev = to_pci_dev(dev);
 	return sprintf (buf, "%d\n", fls64(pdev->dma_mask));
 }
 static ssize_t
 consistent_dma_mask_bits_show(struct device *dev, struct device_attribute *attr,
 				 char *buf)
 {
 	return sprintf (buf, "%d\n", fls64(dev->coherent_dma_mask));
 }
 static ssize_t
 msi_bus_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct pci_dev *pdev = to_pci_dev(dev);
 	if (!pdev->subordinate)
 		return 0;
 	return sprintf (buf, "%u\n",
 			!(pdev->subordinate->bus_flags & PCI_BUS_FLAGS_NO_MSI));
 }
 static ssize_t
 msi_bus_store(struct device *dev, struct device_attribute *attr,
 	      const char *buf, size_t count)
 {
 	struct pci_dev *pdev = to_pci_dev(dev);
 	unsigned long val;
 	if (strict_strtoul(buf, 0, &val) < 0)
 		return -EINVAL;
 	/* bad things may happen if the no_msi flag is changed
 	 * while some drivers are loaded */
 	if (!capable(CAP_SYS_ADMIN))
 		return -EPERM;
 	/* Maybe pci devices without subordinate busses shouldn't even have this
 	 * attribute in the first place?  */
 	if (!pdev->subordinate)
 		return count;
 	/* Is the flag going to change, or keep the value it already had? */
 	if (!(pdev->subordinate->bus_flags & PCI_BUS_FLAGS_NO_MSI) ^
 	    !!val) {
 		pdev->subordinate->bus_flags ^= PCI_BUS_FLAGS_NO_MSI;
 		dev_warn(&pdev->dev, "forced subordinate bus to%s support MSI,"
 			 " bad things could happen\n", val ? "" : " not");
 	}
 	return count;
 }
 #ifdef CONFIG_HOTPLUG
 static DEFINE_MUTEX(pci_remove_rescan_mutex);
 static ssize_t bus_rescan_store(struct bus_type *bus, const char *buf,
 				size_t count)
 {
 	unsigned long val;
 	struct pci_bus *b = NULL;
 	if (strict_strtoul(buf, 0, &val) < 0)
 		return -EINVAL;
 	if (val) {
 		mutex_lock(&pci_remove_rescan_mutex);
 		while ((b = pci_find_next_bus(b)) != NULL)
 			pci_rescan_bus(b);
 		mutex_unlock(&pci_remove_rescan_mutex);
 	}
 	return count;
 }
 struct bus_attribute pci_bus_attrs[] = {
 	__ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, bus_rescan_store),
 	__ATTR_NULL
 };
 static ssize_t
 dev_rescan_store(struct device *dev, struct device_attribute *attr,
 		 const char *buf, size_t count)
 {
 	unsigned long val;
 	struct pci_dev *pdev = to_pci_dev(dev);
 	if (strict_strtoul(buf, 0, &val) < 0)
 		return -EINVAL;
 	if (val) {
 		mutex_lock(&pci_remove_rescan_mutex);
 		pci_rescan_bus(pdev->bus);
 		mutex_unlock(&pci_remove_rescan_mutex);
 	}
 	return count;
 }
 static void remove_callback(struct device *dev)
 {
 	struct pci_dev *pdev = to_pci_dev(dev);
 	mutex_lock(&pci_remove_rescan_mutex);
 	pci_remove_bus_device(pdev);
 	mutex_unlock(&pci_remove_rescan_mutex);
 }
 static ssize_t
 remove_store(struct device *dev, struct device_attribute *dummy,
 	     const char *buf, size_t count)
 {
 	int ret = 0;
 	unsigned long val;
 	if (strict_strtoul(buf, 0, &val) < 0)
 		return -EINVAL;
 	/* An attribute cannot be unregistered by one of its own methods,
 	 * so we have to use this roundabout approach.
 	 */
 	if (val)
 		ret = device_schedule_callback(dev, remove_callback);
 	if (ret)
 		count = ret;
 	return count;
 }
 #endif
 struct device_attribute pci_dev_attrs[] = {
 	__ATTR_RO(resource),
 	__ATTR_RO(vendor),
 	__ATTR_RO(device),
 	__ATTR_RO(subsystem_vendor),
 	__ATTR_RO(subsystem_device),
 	__ATTR_RO(class),
 	__ATTR_RO(irq),
 	__ATTR_RO(local_cpus),
 	__ATTR_RO(local_cpulist),
 	__ATTR_RO(modalias),
 #ifdef CONFIG_NUMA
 	__ATTR_RO(numa_node),
 #endif
 	__ATTR_RO(dma_mask_bits),
 	__ATTR_RO(consistent_dma_mask_bits),
 	__ATTR(enable, 0600, is_enabled_show, is_enabled_store),
 	__ATTR(broken_parity_status,(S_IRUGO|S_IWUSR),
 		broken_parity_status_show,broken_parity_status_store),
 	__ATTR(msi_bus, 0644, msi_bus_show, msi_bus_store),
 #ifdef CONFIG_HOTPLUG
 	__ATTR(remove, (S_IWUSR|S_IWGRP), NULL, remove_store),
 	__ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, dev_rescan_store),
 #endif
 	__ATTR_NULL,
 };
 static ssize_t
 boot_vga_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct pci_dev *pdev = to_pci_dev(dev);
 	return sprintf(buf, "%u\n",
 		!!(pdev->resource[PCI_ROM_RESOURCE].flags &
 		   IORESOURCE_ROM_SHADOW));
 }
 struct device_attribute vga_attr = __ATTR_RO(boot_vga);
 static ssize_t
 pci_read_config(struct file *filp, struct kobject *kobj,
 		struct bin_attribute *bin_attr,
 		char *buf, loff_t off, size_t count)
 {
 	struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj));
 	unsigned int size = 64;
 	loff_t init_off = off;
 	u8 *data = (u8*) buf;
 	/* Several chips lock up trying to read undefined config space */
 	if (cap_raised(filp->f_cred->cap_effective, CAP_SYS_ADMIN)) {
 		size = dev->cfg_size;
 	} else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) {
 		size = 128;
 	}
 	if (off > size)
 		return 0;
 	if (off + count > size) {
 		size -= off;
 		count = size;
 	} else {
 		size = count;
 	}
 	if ((off & 1) && size) {
 		u8 val;
 		pci_user_read_config_byte(dev, off, &val);
 		data[off - init_off] = val;
 		off++;
 		size--;
 	}
 	if ((off & 3) && size > 2) {
 		u16 val;
 		pci_user_read_config_word(dev, off, &val);
 		data[off - init_off] = val & 0xff;
 		data[off - init_off + 1] = (val >> 8) & 0xff;
 		off += 2;
 		size -= 2;
 	}
 	while (size > 3) {
 		u32 val;
 		pci_user_read_config_dword(dev, off, &val);
 		data[off - init_off] = val & 0xff;
 		data[off - init_off + 1] = (val >> 8) & 0xff;
 		data[off - init_off + 2] = (val >> 16) & 0xff;
 		data[off - init_off + 3] = (val >> 24) & 0xff;
 		off += 4;
 		size -= 4;
 	}
 	if (size >= 2) {
 		u16 val;
 		pci_user_read_config_word(dev, off, &val);
 		data[off - init_off] = val & 0xff;
 		data[off - init_off + 1] = (val >> 8) & 0xff;
 		off += 2;
 		size -= 2;
 	}
 	if (size > 0) {
 		u8 val;
 		pci_user_read_config_byte(dev, off, &val);
 		data[off - init_off] = val;
 		off++;
 		--size;
 	}
 	return count;
 }
 static ssize_t
 pci_write_config(struct file* filp, struct kobject *kobj,
 		 struct bin_attribute *bin_attr,
 		 char *buf, loff_t off, size_t count)
 {
 	struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj));
 	unsigned int size = count;
 	loff_t init_off = off;
 	u8 *data = (u8*) buf;
 	if (off > dev->cfg_size)
 		return 0;
 	if (off + count > dev->cfg_size) {
 		size = dev->cfg_size - off;
 		count = size;
 	}
 	if ((off & 1) && size) {
 		pci_user_write_config_byte(dev, off, data[off - init_off]);
 		off++;
 		size--;
 	}
 	if ((off & 3) && size > 2) {
 		u16 val = data[off - init_off];
 		val |= (u16) data[off - init_off + 1] << 8;
                 pci_user_write_config_word(dev, off, val);
                 off += 2;
                 size -= 2;
         }
 	while (size > 3) {
 		u32 val = data[off - init_off];
 		val |= (u32) data[off - init_off + 1] << 8;
 		val |= (u32) data[off - init_off + 2] << 16;
 		val |= (u32) data[off - init_off + 3] << 24;
 		pci_user_write_config_dword(dev, off, val);
 		off += 4;
 		size -= 4;
 	}
 	if (size >= 2) {
 		u16 val = data[off - init_off];
 		val |= (u16) data[off - init_off + 1] << 8;
 		pci_user_write_config_word(dev, off, val);
 		off += 2;
 		size -= 2;
 	}
 	if (size) {
 		pci_user_write_config_byte(dev, off, data[off - init_off]);
 		off++;
 		--size;
 	}
 	return count;
 }
 static ssize_t
 read_vpd_attr(struct file *filp, struct kobject *kobj,
 	      struct bin_attribute *bin_attr,
 	      char *buf, loff_t off, size_t count)
 {
 	struct pci_dev *dev =
 		to_pci_dev(container_of(kobj, struct device, kobj));
 	if (off > bin_attr->size)
 		count = 0;
 	else if (count > bin_attr->size - off)
 		count = bin_attr->size - off;
 	return pci_read_vpd(dev, off, count, buf);
 }
 static ssize_t
 write_vpd_attr(struct file *filp, struct kobject *kobj,
 	       struct bin_attribute *bin_attr,
 	       char *buf, loff_t off, size_t count)
 {
 	struct pci_dev *dev =
 		to_pci_dev(container_of(kobj, struct device, kobj));
 	if (off > bin_attr->size)
 		count = 0;
 	else if (count > bin_attr->size - off)
 		count = bin_attr->size - off;
 	return pci_write_vpd(dev, off, count, buf);
 }
 #ifdef HAVE_PCI_LEGACY
 /**
  * pci_read_legacy_io - read byte(s) from legacy I/O port space
  * @filp: open sysfs file
  * @kobj: kobject corresponding to file to read from
  * @bin_attr: struct bin_attribute for this file
  * @buf: buffer to store results
  * @off: offset into legacy I/O port space
  * @count: number of bytes to read
  *
  * Reads 1, 2, or 4 bytes from legacy I/O port space using an arch specific
  * callback routine (pci_legacy_read).
  */
 static ssize_t
 pci_read_legacy_io(struct file *filp, struct kobject *kobj,
 		   struct bin_attribute *bin_attr,
 		   char *buf, loff_t off, size_t count)
 {
         struct pci_bus *bus = to_pci_bus(container_of(kobj,
                                                       struct device,
 						      kobj));
         /* Only support 1, 2 or 4 byte accesses */
         if (count != 1 && count != 2 && count != 4)
                 return -EINVAL;
         return pci_legacy_read(bus, off, (u32 *)buf, count);
 }
 /**
  * pci_write_legacy_io - write byte(s) to legacy I/O port space
  * @filp: open sysfs file
  * @kobj: kobject corresponding to file to read from
  * @bin_attr: struct bin_attribute for this file
  * @buf: buffer containing value to be written
  * @off: offset into legacy I/O port space
  * @count: number of bytes to write
  *
  * Writes 1, 2, or 4 bytes from legacy I/O port space using an arch specific
  * callback routine (pci_legacy_write).
  */
 static ssize_t
 pci_write_legacy_io(struct file *filp, struct kobject *kobj,
 		    struct bin_attribute *bin_attr,
 		    char *buf, loff_t off, size_t count)
 {
         struct pci_bus *bus = to_pci_bus(container_of(kobj,
 						      struct device,
 						      kobj));
         /* Only support 1, 2 or 4 byte accesses */
         if (count != 1 && count != 2 && count != 4)
                 return -EINVAL;
         return pci_legacy_write(bus, off, *(u32 *)buf, count);
 }
 /**
  * pci_mmap_legacy_mem - map legacy PCI memory into user memory space
  * @filp: open sysfs file
  * @kobj: kobject corresponding to device to be mapped
  * @attr: struct bin_attribute for this file
  * @vma: struct vm_area_struct passed to mmap
  *
  * Uses an arch specific callback, pci_mmap_legacy_mem_page_range, to mmap
  * legacy memory space (first meg of bus space) into application virtual
  * memory space.
  */
 static int
 pci_mmap_legacy_mem(struct file *filp, struct kobject *kobj,
 		    struct bin_attribute *attr,
                     struct vm_area_struct *vma)
 {
         struct pci_bus *bus = to_pci_bus(container_of(kobj,
                                                       struct device,
 						      kobj));
         return pci_mmap_legacy_page_range(bus, vma, pci_mmap_mem);
 }
 /**
  * pci_mmap_legacy_io - map legacy PCI IO into user memory space
  * @filp: open sysfs file
  * @kobj: kobject corresponding to device to be mapped
  * @attr: struct bin_attribute for this file
  * @vma: struct vm_area_struct passed to mmap
  *
  * Uses an arch specific callback, pci_mmap_legacy_io_page_range, to mmap
  * legacy IO space (first meg of bus space) into application virtual
  * memory space. Returns -ENOSYS if the operation isn't supported
  */
 static int
 pci_mmap_legacy_io(struct file *filp, struct kobject *kobj,
 		   struct bin_attribute *attr,
 		   struct vm_area_struct *vma)
 {
         struct pci_bus *bus = to_pci_bus(container_of(kobj,
                                                       struct device,
 						      kobj));
         return pci_mmap_legacy_page_range(bus, vma, pci_mmap_io);
 }
 /**
  * pci_adjust_legacy_attr - adjustment of legacy file attributes
  * @b: bus to create files under
  * @mmap_type: I/O port or memory
  *
  * Stub implementation. Can be overridden by arch if necessary.
  */
 void __weak
 pci_adjust_legacy_attr(struct pci_bus *b, enum pci_mmap_state mmap_type)
 {
 	return;
 }
 /**
  * pci_create_legacy_files - create legacy I/O port and memory files
  * @b: bus to create files under
  *
  * Some platforms allow access to legacy I/O port and ISA memory space on
  * a per-bus basis.  This routine creates the files and ties them into
  * their associated read, write and mmap files from pci-sysfs.c
  *
  * On error unwind, but don't propogate the error to the caller
  * as it is ok to set up the PCI bus without these files.
  */
 void pci_create_legacy_files(struct pci_bus *b)
 {
 	int error;
 	b->legacy_io = kzalloc(sizeof(struct bin_attribute) * 2,
 			       GFP_ATOMIC);
 	if (!b->legacy_io)
 		goto kzalloc_err;
 	sysfs_bin_attr_init(b->legacy_io);
 	b->legacy_io->attr.name = "legacy_io";
 	b->legacy_io->size = 0xffff;
 	b->legacy_io->attr.mode = S_IRUSR | S_IWUSR;
 	b->legacy_io->read = pci_read_legacy_io;
 	b->legacy_io->write = pci_write_legacy_io;
 	b->legacy_io->mmap = pci_mmap_legacy_io;
 	pci_adjust_legacy_attr(b, pci_mmap_io);
 	error = device_create_bin_file(&b->dev, b->legacy_io);
 	if (error)
 		goto legacy_io_err;
 	/* Allocated above after the legacy_io struct */
 	b->legacy_mem = b->legacy_io + 1;
 	sysfs_bin_attr_init(b->legacy_mem);
 	b->legacy_mem->attr.name = "legacy_mem";
 	b->legacy_mem->size = 1024*1024;
 	b->legacy_mem->attr.mode = S_IRUSR | S_IWUSR;
 	b->legacy_mem->mmap = pci_mmap_legacy_mem;
 	pci_adjust_legacy_attr(b, pci_mmap_mem);
 	error = device_create_bin_file(&b->dev, b->legacy_mem);
 	if (error)
 		goto legacy_mem_err;
 	return;
 legacy_mem_err:
 	device_remove_bin_file(&b->dev, b->legacy_io);
 legacy_io_err:
 	kfree(b->legacy_io);
 	b->legacy_io = NULL;
 kzalloc_err:
 	printk(KERN_WARNING "pci: warning: could not create legacy I/O port "
 	       "and ISA memory resources to sysfs\n");
 	return;
 }
 void pci_remove_legacy_files(struct pci_bus *b)
 {
 	if (b->legacy_io) {
 		device_remove_bin_file(&b->dev, b->legacy_io);
 		device_remove_bin_file(&b->dev, b->legacy_mem);
 		kfree(b->legacy_io); /* both are allocated here */
 	}
 }
 #endif /* HAVE_PCI_LEGACY */
 #ifdef HAVE_PCI_MMAP
 int pci_mmap_fits(struct pci_dev *pdev, int resno, struct vm_area_struct *vma)
 {
 	unsigned long nr, start, size;
 	nr = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
 	start = vma->vm_pgoff;
 	size = ((pci_resource_len(pdev, resno) - 1) >> PAGE_SHIFT) + 1;
 	if (start < size && size - start >= nr)
 		return 1;
 	WARN(1, "process \"%s\" tried to map 0x%08lx-0x%08lx on %s BAR %d (size 0x%08lx)\n",
 		current->comm, start, start+nr, pci_name(pdev), resno, size);
 	return 0;
 }
 /**
  * pci_mmap_resource - map a PCI resource into user memory space
  * @kobj: kobject for mapping
  * @attr: struct bin_attribute for the file being mapped
  * @vma: struct vm_area_struct passed into the mmap
  * @write_combine: 1 for write_combine mapping
  *
  * Use the regular PCI mapping routines to map a PCI resource into userspace.
  */
 static int
 pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr,
 		  struct vm_area_struct *vma, int write_combine)
 {
 	struct pci_dev *pdev = to_pci_dev(container_of(kobj,
 						       struct device, kobj));
 	struct resource *res = attr->private;
 	enum pci_mmap_state mmap_type;
 	resource_size_t start, end;
 	int i;
 	for (i = 0; i < PCI_ROM_RESOURCE; i++)
 		if (res == &pdev->resource[i])
 			break;
 	if (i >= PCI_ROM_RESOURCE)
 		return -ENODEV;
 	if (!pci_mmap_fits(pdev, i, vma))
 		return -EINVAL;
 	/* pci_mmap_page_range() expects the same kind of entry as coming
 	 * from /proc/bus/pci/ which is a "user visible" value. If this is
 	 * different from the resource itself, arch will do necessary fixup.
 	 */
 	pci_resource_to_user(pdev, i, res, &start, &end);
 	vma->vm_pgoff += start >> PAGE_SHIFT;
 	mmap_type = res->flags & IORESOURCE_MEM ? pci_mmap_mem : pci_mmap_io;
 	if (res->flags & IORESOURCE_MEM && iomem_is_exclusive(start))
 		return -EINVAL;
 	return pci_mmap_page_range(pdev, vma, mmap_type, write_combine);
 }
 static int
 pci_mmap_resource_uc(struct file *filp, struct kobject *kobj,
 		     struct bin_attribute *attr,
 		     struct vm_area_struct *vma)
 {
 	return pci_mmap_resource(kobj, attr, vma, 0);
 }
 static int
 pci_mmap_resource_wc(struct file *filp, struct kobject *kobj,
 		     struct bin_attribute *attr,
 		     struct vm_area_struct *vma)
 {
 	return pci_mmap_resource(kobj, attr, vma, 1);
 }
 static ssize_t
 pci_resource_io(struct file *filp, struct kobject *kobj,
 		struct bin_attribute *attr, char *buf,
 		loff_t off, size_t count, bool write)
 {
 	struct pci_dev *pdev = to_pci_dev(container_of(kobj,
 						       struct device, kobj));
 	struct resource *res = attr->private;
 	unsigned long port = off;
 	int i;
 	for (i = 0; i < PCI_ROM_RESOURCE; i++)
 		if (res == &pdev->resource[i])
 			break;
 	if (i >= PCI_ROM_RESOURCE)
 		return -ENODEV;
 	port += pci_resource_start(pdev, i);
 	if (port > pci_resource_end(pdev, i))
 		return 0;
 	if (port + count - 1 > pci_resource_end(pdev, i))
 		return -EINVAL;
 	switch (count) {
 	case 1:
 		if (write)
 			outb(*(u8 *)buf, port);
 		else
 			*(u8 *)buf = inb(port);
 		return 1;
 	case 2:
 		if (write)
 			outw(*(u16 *)buf, port);
 		else
 			*(u16 *)buf = inw(port);
 		return 2;
 	case 4:
 		if (write)
 			outl(*(u32 *)buf, port);
 		else
 			*(u32 *)buf = inl(port);
 		return 4;
 	}
 	return -EINVAL;
 }
 static ssize_t
 pci_read_resource_io(struct file *filp, struct kobject *kobj,
 		     struct bin_attribute *attr, char *buf,
 		     loff_t off, size_t count)
 {
 	return pci_resource_io(filp, kobj, attr, buf, off, count, false);
 }
 static ssize_t
 pci_write_resource_io(struct file *filp, struct kobject *kobj,
 		      struct bin_attribute *attr, char *buf,
 		      loff_t off, size_t count)
 {
 	return pci_resource_io(filp, kobj, attr, buf, off, count, true);
 }
 /**
  * pci_remove_resource_files - cleanup resource files
  * @pdev: dev to cleanup
  *
  * If we created resource files for @pdev, remove them from sysfs and
  * free their resources.
  */
 static void
 pci_remove_resource_files(struct pci_dev *pdev)
 {
 	int i;
 	for (i = 0; i < PCI_ROM_RESOURCE; i++) {
 		struct bin_attribute *res_attr;
 		res_attr = pdev->res_attr[i];
 		if (res_attr) {
 			sysfs_remove_bin_file(&pdev->dev.kobj, res_attr);
 			kfree(res_attr);
 		}
 		res_attr = pdev->res_attr_wc[i];
 		if (res_attr) {
 			sysfs_remove_bin_file(&pdev->dev.kobj, res_attr);
 			kfree(res_attr);
 		}
 	}
 }
 static int pci_create_attr(struct pci_dev *pdev, int num, int write_combine)
 {
 	/* allocate attribute structure, piggyback attribute name */
 	int name_len = write_combine ? 13 : 10;
 	struct bin_attribute *res_attr;
 	int retval;
 	res_attr = kzalloc(sizeof(*res_attr) + name_len, GFP_ATOMIC);
 	if (res_attr) {
 		char *res_attr_name = (char *)(res_attr + 1);
 		sysfs_bin_attr_init(res_attr);
 		if (write_combine) {
 			pdev->res_attr_wc[num] = res_attr;
 			sprintf(res_attr_name, "resource%d_wc", num);
 			res_attr->mmap = pci_mmap_resource_wc;
 		} else {
 			pdev->res_attr[num] = res_attr;
 			sprintf(res_attr_name, "resource%d", num);
 			res_attr->mmap = pci_mmap_resource_uc;
 		}
 		if (pci_resource_flags(pdev, num) & IORESOURCE_IO) {
 			res_attr->read = pci_read_resource_io;
 			res_attr->write = pci_write_resource_io;
 		}
 		res_attr->attr.name = res_attr_name;
 		res_attr->attr.mode = S_IRUSR | S_IWUSR;
 		res_attr->size = pci_resource_len(pdev, num);
 		res_attr->private = &pdev->resource[num];
 		retval = sysfs_create_bin_file(&pdev->dev.kobj, res_attr);
 	} else
 		retval = -ENOMEM;
 	return retval;
 }
 /**
  * pci_create_resource_files - create resource files in sysfs for @dev
  * @pdev: dev in question
  *
  * Walk the resources in @pdev creating files for each resource available.
  */
 static int pci_create_resource_files(struct pci_dev *pdev)
 {
 	int i;
 	int retval;
 	/* Expose the PCI resources from this device as files */
 	for (i = 0; i < PCI_ROM_RESOURCE; i++) {
 		/* skip empty resources */
 		if (!pci_resource_len(pdev, i))
 			continue;
 		retval = pci_create_attr(pdev, i, 0);
 		/* for prefetchable resources, create a WC mappable file */
 		if (!retval && pdev->resource[i].flags & IORESOURCE_PREFETCH)
 			retval = pci_create_attr(pdev, i, 1);
 		if (retval) {
 			pci_remove_resource_files(pdev);
 			return retval;
 		}
 	}
 	return 0;
 }
 #else /* !HAVE_PCI_MMAP */
 int __weak pci_create_resource_files(struct pci_dev *dev) { return 0; }
 void __weak pci_remove_resource_files(struct pci_dev *dev) { return; }
 #endif /* HAVE_PCI_MMAP */
 /**
  * pci_write_rom - used to enable access to the PCI ROM display
  * @filp: sysfs file
  * @kobj: kernel object handle
  * @bin_attr: struct bin_attribute for this file
  * @buf: user input
  * @off: file offset
  * @count: number of byte in input
  *
  * writing anything except 0 enables it
  */
 static ssize_t
 pci_write_rom(struct file *filp, struct kobject *kobj,
 	      struct bin_attribute *bin_attr,
 	      char *buf, loff_t off, size_t count)
 {
 	struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj));
 	if ((off ==  0) && (*buf == '0') && (count == 2))
 		pdev->rom_attr_enabled = 0;
 	else
 		pdev->rom_attr_enabled = 1;
 	return count;
 }
 /**
  * pci_read_rom - read a PCI ROM
  * @filp: sysfs file
  * @kobj: kernel object handle
  * @bin_attr: struct bin_attribute for this file
  * @buf: where to put the data we read from the ROM
  * @off: file offset
  * @count: number of bytes to read
  *
  * Put @count bytes starting at @off into @buf from the ROM in the PCI
  * device corresponding to @kobj.
  */
 static ssize_t
 pci_read_rom(struct file *filp, struct kobject *kobj,
 	     struct bin_attribute *bin_attr,
 	     char *buf, loff_t off, size_t count)
 {
 	struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj));
 	void __iomem *rom;
 	size_t size;
 	if (!pdev->rom_attr_enabled)
 		return -EINVAL;
 	rom = pci_map_rom(pdev, &size);	/* size starts out as PCI window size */
 	if (!rom || !size)
 		return -EIO;
 	if (off >= size)
 		count = 0;
 	else {
 		if (off + count > size)
 			count = size - off;
 		memcpy_fromio(buf, rom + off, count);
 	}
 	pci_unmap_rom(pdev, rom);
 	return count;
 }
 static struct bin_attribute pci_config_attr = {
 	.attr =	{
 		.name = "config",
 		.mode = S_IRUGO | S_IWUSR,
 	},
 	.size = PCI_CFG_SPACE_SIZE,
 	.read = pci_read_config,
 	.write = pci_write_config,
 };
 static struct bin_attribute pcie_config_attr = {
 	.attr =	{
 		.name = "config",
 		.mode = S_IRUGO | S_IWUSR,
 	},
 	.size = PCI_CFG_SPACE_EXP_SIZE,
 	.read = pci_read_config,
 	.write = pci_write_config,
 };
 int __attribute__ ((weak)) pcibios_add_platform_entries(struct pci_dev *dev)
 {
 	return 0;
 }
 static ssize_t reset_store(struct device *dev,
 			   struct device_attribute *attr, const char *buf,
 			   size_t count)
 {
 	struct pci_dev *pdev = to_pci_dev(dev);
 	unsigned long val;
 	ssize_t result = strict_strtoul(buf, 0, &val);
 	if (result < 0)
 		return result;
 	if (val != 1)
 		return -EINVAL;
 	result = pci_reset_function(pdev);
 	if (result < 0)
 		return result;
 	return count;
 }
 static struct device_attribute reset_attr = __ATTR(reset, 0200, NULL, reset_store);
 static int pci_create_capabilities_sysfs(struct pci_dev *dev)
 {
 	int retval;
 	struct bin_attribute *attr;
 	/* If the device has VPD, try to expose it in sysfs. */
 	if (dev->vpd) {
 		attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
 		if (!attr)
 			return -ENOMEM;
 		sysfs_bin_attr_init(attr);
 		attr->size = dev->vpd->len;
 		attr->attr.name = "vpd";
 		attr->attr.mode = S_IRUSR | S_IWUSR;
 		attr->read = read_vpd_attr;
 		attr->write = write_vpd_attr;
 		retval = sysfs_create_bin_file(&dev->dev.kobj, attr);
 		if (retval) {
 			kfree(dev->vpd->attr);
 			return retval;
 		}
 		dev->vpd->attr = attr;
 	}
 	/* Active State Power Management */
 	pcie_aspm_create_sysfs_dev_files(dev);
 	if (!pci_probe_reset_function(dev)) {
 		retval = device_create_file(&dev->dev, &reset_attr);
 		if (retval)
 			goto error;
 		dev->reset_fn = 1;
 	}
 	return 0;
 error:
 	pcie_aspm_remove_sysfs_dev_files(dev);
 	if (dev->vpd && dev->vpd->attr) {
 		sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr);
 		kfree(dev->vpd->attr);
 	}
 	return retval;
 }
 int __must_check pci_create_sysfs_dev_files (struct pci_dev *pdev)
 {
 	int retval;
 	int rom_size = 0;
 	struct bin_attribute *attr;
 	if (!sysfs_initialized)
 		return -EACCES;
 	if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
 		retval = sysfs_create_bin_file(&pdev->dev.kobj, &pci_config_attr);
 	else
 		retval = sysfs_create_bin_file(&pdev->dev.kobj, &pcie_config_attr);
 	if (retval)
 		goto err;
 	retval = pci_create_resource_files(pdev);
 	if (retval)
 		goto err_config_file;
 	if (pci_resource_len(pdev, PCI_ROM_RESOURCE))
 		rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
 	else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)
 		rom_size = 0x20000;
 	/* If the device has a ROM, try to expose it in sysfs. */
 	if (rom_size) {
 		attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
 		if (!attr) {
 			retval = -ENOMEM;
 			goto err_resource_files;
 		}
 		sysfs_bin_attr_init(attr);
 		attr->size = rom_size;
 		attr->attr.name = "rom";
 		attr->attr.mode = S_IRUSR;
 		attr->read = pci_read_rom;
 		attr->write = pci_write_rom;
 		retval = sysfs_create_bin_file(&pdev->dev.kobj, attr);
 		if (retval) {
 			kfree(attr);
 			goto err_resource_files;
 		}
 		pdev->rom_attr = attr;
 	}
 	if ((pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA) {
 		retval = device_create_file(&pdev->dev, &vga_attr);
 		if (retval)
 			goto err_rom_file;
 	}
 	/* add platform-specific attributes */
 	retval = pcibios_add_platform_entries(pdev);
 	if (retval)
 		goto err_vga_file;
 	/* add sysfs entries for various capabilities */
 	retval = pci_create_capabilities_sysfs(pdev);
 	if (retval)
 		goto err_vga_file;
+	pci_create_firmware_label_files(pdev);
 	return 0;
 err_vga_file:
 	if ((pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA)
 		device_remove_file(&pdev->dev, &vga_attr);
 err_rom_file:
 	if (rom_size) {
 		sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
 		kfree(pdev->rom_attr);
 		pdev->rom_attr = NULL;
 	}
 err_resource_files:
 	pci_remove_resource_files(pdev);
 err_config_file:
 	if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
 		sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr);
 	else
 		sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr);
 err:
 	return retval;
 }
 static void pci_remove_capabilities_sysfs(struct pci_dev *dev)
 {
 	if (dev->vpd && dev->vpd->attr) {
 		sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr);
 		kfree(dev->vpd->attr);
 	}
 	pcie_aspm_remove_sysfs_dev_files(dev);
 	if (dev->reset_fn) {
 		device_remove_file(&dev->dev, &reset_attr);
 		dev->reset_fn = 0;
 	}
 }
 /**
  * pci_remove_sysfs_dev_files - cleanup PCI specific sysfs files
  * @pdev: device whose entries we should free
  *
  * Cleanup when @pdev is removed from sysfs.
  */
 void pci_remove_sysfs_dev_files(struct pci_dev *pdev)
 {
 	int rom_size = 0;
 	if (!sysfs_initialized)
 		return;
 	pci_remove_capabilities_sysfs(pdev);
 	if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
 		sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr);
 	else
 		sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr);
 	pci_remove_resource_files(pdev);
 	if (pci_resource_len(pdev, PCI_ROM_RESOURCE))
 		rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
 	else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)
 		rom_size = 0x20000;
 	if (rom_size && pdev->rom_attr) {
 		sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
 		kfree(pdev->rom_attr);
 	}
+	pci_remove_firmware_label_files(pdev);
 }
 static int __init pci_sysfs_init(void)
 {
 	struct pci_dev *pdev = NULL;
 	int retval;
 	sysfs_initialized = 1;
 	for_each_pci_dev(pdev) {
 		retval = pci_create_sysfs_dev_files(pdev);
 		if (retval) {
 			pci_dev_put(pdev);
 			return retval;
 		}
 	}
 	return 0;
 }
 late_initcall(pci_sysfs_init);

drivers/pci/pci.h

Diff comments View file @ 911e1c9

 #ifndef DRIVERS_PCI_H
 #define DRIVERS_PCI_H
 #include <linux/workqueue.h>
 #define PCI_CFG_SPACE_SIZE	256
 #define PCI_CFG_SPACE_EXP_SIZE	4096
 /* Functions internal to the PCI core code */
 extern int pci_uevent(struct device *dev, struct kobj_uevent_env *env);
 extern int pci_create_sysfs_dev_files(struct pci_dev *pdev);
 extern void pci_remove_sysfs_dev_files(struct pci_dev *pdev);
+#ifndef CONFIG_DMI
+static inline void pci_create_firmware_label_files(struct pci_dev *pdev)
+{ return 0; }
+static inline void pci_remove_firmware_label_files(struct pci_dev *pdev)
+{ return 0; }
+#else
+extern void pci_create_firmware_label_files(struct pci_dev *pdev);
+extern void pci_remove_firmware_label_files(struct pci_dev *pdev);
+#endif
 extern void pci_cleanup_rom(struct pci_dev *dev);
 #ifdef HAVE_PCI_MMAP
 extern int pci_mmap_fits(struct pci_dev *pdev, int resno,
 			 struct vm_area_struct *vma);
 #endif
 int pci_probe_reset_function(struct pci_dev *dev);
 /**
  * struct pci_platform_pm_ops - Firmware PM callbacks
  *
  * @is_manageable: returns 'true' if given device is power manageable by the
  *                 platform firmware
  *
  * @set_state: invokes the platform firmware to set the device's power state
  *
  * @choose_state: returns PCI power state of given device preferred by the
  *                platform; to be used during system-wide transitions from a
  *                sleeping state to the working state and vice versa
  *
  * @can_wakeup: returns 'true' if given device is capable of waking up the
  *              system from a sleeping state
  *
  * @sleep_wake: enables/disables the system wake up capability of given device
  *
  * @run_wake: enables/disables the platform to generate run-time wake-up events
  *		for given device (the device's wake-up capability has to be
  *		enabled by @sleep_wake for this feature to work)
  *
  * If given platform is generally capable of power managing PCI devices, all of
  * these callbacks are mandatory.
  */
 struct pci_platform_pm_ops {
 	bool (*is_manageable)(struct pci_dev *dev);
 	int (*set_state)(struct pci_dev *dev, pci_power_t state);
 	pci_power_t (*choose_state)(struct pci_dev *dev);
 	bool (*can_wakeup)(struct pci_dev *dev);
 	int (*sleep_wake)(struct pci_dev *dev, bool enable);
 	int (*run_wake)(struct pci_dev *dev, bool enable);
 };
 extern int pci_set_platform_pm(struct pci_platform_pm_ops *ops);
 extern void pci_update_current_state(struct pci_dev *dev, pci_power_t state);
 extern void pci_disable_enabled_device(struct pci_dev *dev);
 extern bool pci_check_pme_status(struct pci_dev *dev);
 extern int pci_finish_runtime_suspend(struct pci_dev *dev);
 extern int __pci_pme_wakeup(struct pci_dev *dev, void *ign);
 extern void pci_pme_wakeup_bus(struct pci_bus *bus);
 extern void pci_pm_init(struct pci_dev *dev);
 extern void platform_pci_wakeup_init(struct pci_dev *dev);
 extern void pci_allocate_cap_save_buffers(struct pci_dev *dev);
 static inline bool pci_is_bridge(struct pci_dev *pci_dev)
 {
 	return !!(pci_dev->subordinate);
 }
 extern int pci_user_read_config_byte(struct pci_dev *dev, int where, u8 *val);
 extern int pci_user_read_config_word(struct pci_dev *dev, int where, u16 *val);
 extern int pci_user_read_config_dword(struct pci_dev *dev, int where, u32 *val);
 extern int pci_user_write_config_byte(struct pci_dev *dev, int where, u8 val);
 extern int pci_user_write_config_word(struct pci_dev *dev, int where, u16 val);
 extern int pci_user_write_config_dword(struct pci_dev *dev, int where, u32 val);
 struct pci_vpd_ops {
 	ssize_t (*read)(struct pci_dev *dev, loff_t pos, size_t count, void *buf);
 	ssize_t (*write)(struct pci_dev *dev, loff_t pos, size_t count, const void *buf);
 	void (*release)(struct pci_dev *dev);
 };
 struct pci_vpd {
 	unsigned int len;
 	const struct pci_vpd_ops *ops;
 	struct bin_attribute *attr; /* descriptor for sysfs VPD entry */
 };
 extern int pci_vpd_pci22_init(struct pci_dev *dev);
 static inline void pci_vpd_release(struct pci_dev *dev)
 {
 	if (dev->vpd)
 		dev->vpd->ops->release(dev);
 }
 /* PCI /proc functions */
 #ifdef CONFIG_PROC_FS
 extern int pci_proc_attach_device(struct pci_dev *dev);
 extern int pci_proc_detach_device(struct pci_dev *dev);
 extern int pci_proc_detach_bus(struct pci_bus *bus);
 #else
 static inline int pci_proc_attach_device(struct pci_dev *dev) { return 0; }
 static inline int pci_proc_detach_device(struct pci_dev *dev) { return 0; }
 static inline int pci_proc_detach_bus(struct pci_bus *bus) { return 0; }
 #endif
 /* Functions for PCI Hotplug drivers to use */
 extern unsigned int pci_do_scan_bus(struct pci_bus *bus);
 #ifdef HAVE_PCI_LEGACY
 extern void pci_create_legacy_files(struct pci_bus *bus);
 extern void pci_remove_legacy_files(struct pci_bus *bus);
 #else
 static inline void pci_create_legacy_files(struct pci_bus *bus) { return; }
 static inline void pci_remove_legacy_files(struct pci_bus *bus) { return; }
 #endif
 /* Lock for read/write access to pci device and bus lists */
 extern struct rw_semaphore pci_bus_sem;
 extern unsigned int pci_pm_d3_delay;
 #ifdef CONFIG_PCI_MSI
 void pci_no_msi(void);
 extern void pci_msi_init_pci_dev(struct pci_dev *dev);
 #else
 static inline void pci_no_msi(void) { }
 static inline void pci_msi_init_pci_dev(struct pci_dev *dev) { }
 #endif
 #ifdef CONFIG_PCIEAER
 void pci_no_aer(void);
 #else
 static inline void pci_no_aer(void) { }
 #endif
 static inline int pci_no_d1d2(struct pci_dev *dev)
 {
 	unsigned int parent_dstates = 0;
 	if (dev->bus->self)
 		parent_dstates = dev->bus->self->no_d1d2;
 	return (dev->no_d1d2 || parent_dstates);
 }
 extern struct device_attribute pci_dev_attrs[];
 extern struct device_attribute dev_attr_cpuaffinity;
 extern struct device_attribute dev_attr_cpulistaffinity;
 #ifdef CONFIG_HOTPLUG
 extern struct bus_attribute pci_bus_attrs[];
 #else
 #define pci_bus_attrs	NULL
 #endif
 /**
  * pci_match_one_device - Tell if a PCI device structure has a matching
  *                        PCI device id structure
  * @id: single PCI device id structure to match
  * @dev: the PCI device structure to match against
  *
  * Returns the matching pci_device_id structure or %NULL if there is no match.
  */
 static inline const struct pci_device_id *
 pci_match_one_device(const struct pci_device_id *id, const struct pci_dev *dev)
 {
 	if ((id->vendor == PCI_ANY_ID || id->vendor == dev->vendor) &&
 	    (id->device == PCI_ANY_ID || id->device == dev->device) &&
 	    (id->subvendor == PCI_ANY_ID || id->subvendor == dev->subsystem_vendor) &&
 	    (id->subdevice == PCI_ANY_ID || id->subdevice == dev->subsystem_device) &&
 	    !((id->class ^ dev->class) & id->class_mask))
 		return id;
 	return NULL;
 }
 struct pci_dev *pci_find_upstream_pcie_bridge(struct pci_dev *pdev);
 /* PCI slot sysfs helper code */
 #define to_pci_slot(s) container_of(s, struct pci_slot, kobj)
 extern struct kset *pci_slots_kset;
 struct pci_slot_attribute {
 	struct attribute attr;
 	ssize_t (*show)(struct pci_slot *, char *);
 	ssize_t (*store)(struct pci_slot *, const char *, size_t);
 };
 #define to_pci_slot_attr(s) container_of(s, struct pci_slot_attribute, attr)
 enum pci_bar_type {
 	pci_bar_unknown,	/* Standard PCI BAR probe */
 	pci_bar_io,		/* An io port BAR */
 	pci_bar_mem32,		/* A 32-bit memory BAR */
 	pci_bar_mem64,		/* A 64-bit memory BAR */
 };
 extern int pci_setup_device(struct pci_dev *dev);
 extern int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
 				struct resource *res, unsigned int reg);
 extern int pci_resource_bar(struct pci_dev *dev, int resno,
 			    enum pci_bar_type *type);
 extern int pci_bus_add_child(struct pci_bus *bus);
 extern void pci_enable_ari(struct pci_dev *dev);
 /**
  * pci_ari_enabled - query ARI forwarding status
  * @bus: the PCI bus
  *
  * Returns 1 if ARI forwarding is enabled, or 0 if not enabled;
  */
 static inline int pci_ari_enabled(struct pci_bus *bus)
 {
 	return bus->self && bus->self->ari_enabled;
 }
 #ifdef CONFIG_PCI_QUIRKS
 extern int pci_is_reassigndev(struct pci_dev *dev);
 resource_size_t pci_specified_resource_alignment(struct pci_dev *dev);
 extern void pci_disable_bridge_window(struct pci_dev *dev);
 #endif
 /* Single Root I/O Virtualization */
 struct pci_sriov {
 	int pos;		/* capability position */
 	int nres;		/* number of resources */
 	u32 cap;		/* SR-IOV Capabilities */
 	u16 ctrl;		/* SR-IOV Control */
 	u16 total;		/* total VFs associated with the PF */
 	u16 initial;		/* initial VFs associated with the PF */
 	u16 nr_virtfn;		/* number of VFs available */
 	u16 offset;		/* first VF Routing ID offset */
 	u16 stride;		/* following VF stride */
 	u32 pgsz;		/* page size for BAR alignment */
 	u8 link;		/* Function Dependency Link */
 	struct pci_dev *dev;	/* lowest numbered PF */
 	struct pci_dev *self;	/* this PF */
 	struct mutex lock;	/* lock for VF bus */
 	struct work_struct mtask; /* VF Migration task */
 	u8 __iomem *mstate;	/* VF Migration State Array */
 };
 /* Address Translation Service */
 struct pci_ats {
 	int pos;	/* capability position */
 	int stu;	/* Smallest Translation Unit */
 	int qdep;	/* Invalidate Queue Depth */
 	int ref_cnt;	/* Physical Function reference count */
 	unsigned int is_enabled:1;	/* Enable bit is set */
 };
 #ifdef CONFIG_PCI_IOV
 extern int pci_iov_init(struct pci_dev *dev);
 extern void pci_iov_release(struct pci_dev *dev);
 extern int pci_iov_resource_bar(struct pci_dev *dev, int resno,
 				enum pci_bar_type *type);
 extern int pci_sriov_resource_alignment(struct pci_dev *dev, int resno);
 extern void pci_restore_iov_state(struct pci_dev *dev);
 extern int pci_iov_bus_range(struct pci_bus *bus);
 extern int pci_enable_ats(struct pci_dev *dev, int ps);
 extern void pci_disable_ats(struct pci_dev *dev);
 extern int pci_ats_queue_depth(struct pci_dev *dev);
 /**
  * pci_ats_enabled - query the ATS status
  * @dev: the PCI device
  *
  * Returns 1 if ATS capability is enabled, or 0 if not.
  */
 static inline int pci_ats_enabled(struct pci_dev *dev)
 {
 	return dev->ats && dev->ats->is_enabled;
 }
 #else
 static inline int pci_iov_init(struct pci_dev *dev)
 {
 	return -ENODEV;
 }
 static inline void pci_iov_release(struct pci_dev *dev)
 {
 }
 static inline int pci_iov_resource_bar(struct pci_dev *dev, int resno,
 				       enum pci_bar_type *type)
 {
 	return 0;
 }
 static inline void pci_restore_iov_state(struct pci_dev *dev)
 {
 }
 static inline int pci_iov_bus_range(struct pci_bus *bus)
 {
 	return 0;
 }
 static inline int pci_enable_ats(struct pci_dev *dev, int ps)
 {
 	return -ENODEV;
 }
 static inline void pci_disable_ats(struct pci_dev *dev)
 {
 }
 static inline int pci_ats_queue_depth(struct pci_dev *dev)
 {
 	return -ENODEV;
 }
 static inline int pci_ats_enabled(struct pci_dev *dev)
 {
 	return 0;
 }
 #endif /* CONFIG_PCI_IOV */
 static inline int pci_resource_alignment(struct pci_dev *dev,
 					 struct resource *res)
 {
 #ifdef CONFIG_PCI_IOV
 	int resno = res - dev->resource;
 	if (resno >= PCI_IOV_RESOURCES && resno <= PCI_IOV_RESOURCE_END)
 		return pci_sriov_resource_alignment(dev, resno);
 #endif
 	return resource_alignment(res);
 }
 extern void pci_enable_acs(struct pci_dev *dev);
 struct pci_dev_reset_methods {
 	u16 vendor;
 	u16 device;
 	int (*reset)(struct pci_dev *dev, int probe);
 };
 #ifdef CONFIG_PCI_QUIRKS
 extern int pci_dev_specific_reset(struct pci_dev *dev, int probe);
 #else
 static inline int pci_dev_specific_reset(struct pci_dev *dev, int probe)
 {
 	return -ENOTTY;
 }
 #endif
 #endif /* DRIVERS_PCI_H */

include/linux/dmi.h

Diff comments View file @ 911e1c9

 #ifndef __DMI_H__
 #define __DMI_H__
 #include <linux/list.h>
 #include <linux/mod_devicetable.h>
 /* enum dmi_field is in mod_devicetable.h */
 enum dmi_device_type {
 	DMI_DEV_TYPE_ANY = 0,
 	DMI_DEV_TYPE_OTHER,
 	DMI_DEV_TYPE_UNKNOWN,
 	DMI_DEV_TYPE_VIDEO,
 	DMI_DEV_TYPE_SCSI,
 	DMI_DEV_TYPE_ETHERNET,
 	DMI_DEV_TYPE_TOKENRING,
 	DMI_DEV_TYPE_SOUND,
 	DMI_DEV_TYPE_PATA,
 	DMI_DEV_TYPE_SATA,
 	DMI_DEV_TYPE_SAS,
 	DMI_DEV_TYPE_IPMI = -1,
 	DMI_DEV_TYPE_OEM_STRING = -2,
+	DMI_DEV_TYPE_DEV_ONBOARD = -3,
 };
 struct dmi_header {
 	u8 type;
 	u8 length;
 	u16 handle;
 };
 struct dmi_device {
 	struct list_head list;
 	int type;
 	const char *name;
 	void *device_data;	/* Type specific data */
 };
 #ifdef CONFIG_DMI
+struct dmi_dev_onboard {
+	struct dmi_device dev;
+	int instance;
+	int segment;
+	int bus;
+	int devfn;
+};
 extern int dmi_check_system(const struct dmi_system_id *list);
 const struct dmi_system_id *dmi_first_match(const struct dmi_system_id *list);
 extern const char * dmi_get_system_info(int field);
 extern const struct dmi_device * dmi_find_device(int type, const char *name,
 	const struct dmi_device *from);
 extern void dmi_scan_machine(void);
 extern bool dmi_get_date(int field, int *yearp, int *monthp, int *dayp);
 extern int dmi_name_in_vendors(const char *str);
 extern int dmi_name_in_serial(const char *str);
 extern int dmi_available;
 extern int dmi_walk(void (*decode)(const struct dmi_header *, void *),
 	void *private_data);
 extern bool dmi_match(enum dmi_field f, const char *str);
 #else
 static inline int dmi_check_system(const struct dmi_system_id *list) { return 0; }
 static inline const char * dmi_get_system_info(int field) { return NULL; }
 static inline const struct dmi_device * dmi_find_device(int type, const char *name,
 	const struct dmi_device *from) { return NULL; }
 static inline void dmi_scan_machine(void) { return; }
 static inline bool dmi_get_date(int field, int *yearp, int *monthp, int *dayp)
 {
 	if (yearp)
 		*yearp = 0;
 	if (monthp)
 		*monthp = 0;
 	if (dayp)
 		*dayp = 0;
 	return false;
 }
 static inline int dmi_name_in_vendors(const char *s) { return 0; }
 static inline int dmi_name_in_serial(const char *s) { return 0; }
 #define dmi_available 0
 static inline int dmi_walk(void (*decode)(const struct dmi_header *, void *),
 	void *private_data) { return -1; }
 static inline bool dmi_match(enum dmi_field f, const char *str)
 	{ return false; }
 static inline const struct dmi_system_id *
 	dmi_first_match(const struct dmi_system_id *list) { return NULL; }
 #endif
 #endif	/* __DMI_H__ */