2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* 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>
|
2008-10-02 19:52:51 -06:00
|
|
|
#include <linux/sched.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/stat.h>
|
|
|
|
#include <linux/topology.h>
|
|
|
|
#include <linux/mm.h>
|
2007-07-16 00:40:39 -06:00
|
|
|
#include <linux/capability.h>
|
PCI: add PCI Express ASPM support
PCI Express ASPM defines a protocol for PCI Express components in the D0
state to reduce Link power by placing their Links into a low power state
and instructing the other end of the Link to do likewise. This
capability allows hardware-autonomous, dynamic Link power reduction
beyond what is achievable by software-only controlled power management.
However, The device should be configured by software appropriately.
Enabling ASPM will save power, but will introduce device latency.
This patch adds ASPM support in Linux. It introduces a global policy for
ASPM, a sysfs file /sys/module/pcie_aspm/parameters/policy can control
it. The interface can be used as a boot option too. Currently we have
below setting:
-default, BIOS default setting
-powersave, highest power saving mode, enable all available ASPM
state and clock power management
-performance, highest performance, disable ASPM and clock power
management
By default, the 'default' policy is used currently.
In my test, power difference between powersave mode and performance mode
is about 1.3w in a system with 3 PCIE links.
Note: some devices might not work well with aspm, either because chipset
issue or device issue. The patch provide API (pci_disable_link_state),
driver can disable ASPM for specific device.
Signed-off-by: Shaohua Li <shaohua.li@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2008-02-24 18:46:41 -07:00
|
|
|
#include <linux/pci-aspm.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "pci.h"
|
|
|
|
|
|
|
|
static int sysfs_initialized; /* = 0 */
|
|
|
|
|
|
|
|
/* show configuration fields */
|
|
|
|
#define pci_config_attr(field, format_string) \
|
|
|
|
static ssize_t \
|
2005-05-17 04:42:58 -06:00
|
|
|
field##_show(struct device *dev, struct device_attribute *attr, char *buf) \
|
2005-04-16 16:20:36 -06:00
|
|
|
{ \
|
|
|
|
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");
|
|
|
|
|
2006-06-14 17:59:48 -06:00
|
|
|
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);
|
PCI: Make settable sysfs attributes more consistent
PCI devices have three settable boolean attributes, enable,
broken_parity_status, and msi_bus.
The store functions for these would silently interpret "0x01" as false,
"1llogical" as true, and "true" would be (silently!) ignored and do
nothing.
This is inconsistent with typical sysfs handling of settable attributes,
and just plain doesn't make much sense.
So, use strict_strtoul(), which was created for this purpose. The store
functions will treat a value of 0 as false, non-zero as true, and return
-EINVAL for a parse failure.
Additionally, is_enabled_store() and msi_bus_store() return -EPERM if
CAP_SYS_ADMIN is lacking, rather than silently doing nothing. This is more
typical behavior for sysfs attributes that need a capability.
And msi_bus_store() will only print the "forced subordinate bus ..."
warning if the MSI flag was actually forced to a different value.
Signed-off-by: Trent Piepho <xyzzy@speakeasy.org>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2008-11-30 18:10:12 -07:00
|
|
|
unsigned long val;
|
2006-06-14 17:59:48 -06:00
|
|
|
|
PCI: Make settable sysfs attributes more consistent
PCI devices have three settable boolean attributes, enable,
broken_parity_status, and msi_bus.
The store functions for these would silently interpret "0x01" as false,
"1llogical" as true, and "true" would be (silently!) ignored and do
nothing.
This is inconsistent with typical sysfs handling of settable attributes,
and just plain doesn't make much sense.
So, use strict_strtoul(), which was created for this purpose. The store
functions will treat a value of 0 as false, non-zero as true, and return
-EINVAL for a parse failure.
Additionally, is_enabled_store() and msi_bus_store() return -EPERM if
CAP_SYS_ADMIN is lacking, rather than silently doing nothing. This is more
typical behavior for sysfs attributes that need a capability.
And msi_bus_store() will only print the "forced subordinate bus ..."
warning if the MSI flag was actually forced to a different value.
Signed-off-by: Trent Piepho <xyzzy@speakeasy.org>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2008-11-30 18:10:12 -07:00
|
|
|
if (strict_strtoul(buf, 0, &val) < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
pdev->broken_parity_status = !!val;
|
|
|
|
|
|
|
|
return count;
|
2006-06-14 17:59:48 -06:00
|
|
|
}
|
|
|
|
|
2005-09-10 01:25:49 -06:00
|
|
|
static ssize_t local_cpus_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-09-10 01:25:49 -06:00
|
|
|
cpumask_t mask;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
mask = pcibus_to_cpumask(to_pci_dev(dev)->bus);
|
2008-12-13 03:50:25 -07:00
|
|
|
len = cpumask_scnprintf(buf, PAGE_SIZE-2, &mask);
|
2008-04-08 12:43:03 -06:00
|
|
|
buf[len++] = '\n';
|
|
|
|
buf[len] = '\0';
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static ssize_t local_cpulist_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
cpumask_t mask;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
mask = pcibus_to_cpumask(to_pci_dev(dev)->bus);
|
2008-12-13 03:50:25 -07:00
|
|
|
len = cpulist_scnprintf(buf, PAGE_SIZE-2, &mask);
|
2008-04-08 12:43:03 -06:00
|
|
|
buf[len++] = '\n';
|
|
|
|
buf[len] = '\0';
|
|
|
|
return len;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* show resources */
|
|
|
|
static ssize_t
|
2005-05-17 04:42:58 -06:00
|
|
|
resource_show(struct device * dev, struct device_attribute *attr, char * buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct pci_dev * pci_dev = to_pci_dev(dev);
|
|
|
|
char * str = buf;
|
|
|
|
int i;
|
2008-11-21 11:39:32 -07:00
|
|
|
int max;
|
2006-06-12 18:06:02 -06:00
|
|
|
resource_size_t start, end;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (pci_dev->subordinate)
|
|
|
|
max = DEVICE_COUNT_RESOURCE;
|
2008-11-21 11:39:32 -07:00
|
|
|
else
|
|
|
|
max = PCI_BRIDGE_RESOURCES;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
for (i = 0; i < max; i++) {
|
2005-05-13 01:44:10 -06:00
|
|
|
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);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return (str - buf);
|
|
|
|
}
|
|
|
|
|
2005-06-19 04:21:43 -06:00
|
|
|
static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
|
2005-05-05 12:57:25 -06:00
|
|
|
{
|
|
|
|
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));
|
|
|
|
}
|
PCI: switch pci_{enable,disable}_device() to be nestable
Changes the pci_{enable,disable}_device() functions to work in a
nested basis, so that eg, three calls to enable_device() require three
calls to disable_device().
The reason for this is to simplify PCI drivers for
multi-interface/capability devices. These are devices that cram more
than one interface in a single function. A relevant example of that is
the Wireless [USB] Host Controller Interface (similar to EHCI) [see
http://www.intel.com/technology/comms/wusb/whci.htm].
In these kind of devices, multiple interfaces are accessed through a
single bar and IRQ line. For that, the drivers map only the smallest
area of the bar to access their register banks and use shared IRQ
handlers.
However, because the order at which those drivers load cannot be known
ahead of time, the sequence in which the calls to pci_enable_device()
and pci_disable_device() cannot be predicted. Thus:
1. driverA starts pci_enable_device()
2. driverB starts pci_enable_device()
3. driverA shutdown pci_disable_device()
4. driverB shutdown pci_disable_device()
between steps 3 and 4, driver B would loose access to it's device,
even if it didn't intend to.
By using this modification, the device won't be disabled until all the
callers to enable() have called disable().
This is implemented by replacing 'struct pci_dev->is_enabled' from a
bitfield to an atomic use count. Each caller to enable increments it,
each caller to disable decrements it. When the count increments from 0
to 1, __pci_enable_device() is called to actually enable the
device. When it drops to zero, pci_disable_device() actually does the
disabling.
We keep the backend __pci_enable_device() for pci_default_resume() to
use and also change the sysfs method implementation, so that userspace
enabling/disabling the device doesn't disable it one time too much.
Signed-off-by: Inaky Perez-Gonzalez <inaky@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-11-22 13:40:31 -07:00
|
|
|
|
|
|
|
static ssize_t is_enabled_store(struct device *dev,
|
|
|
|
struct device_attribute *attr, const char *buf,
|
|
|
|
size_t count)
|
2006-04-29 02:59:08 -06:00
|
|
|
{
|
|
|
|
struct pci_dev *pdev = to_pci_dev(dev);
|
PCI: Make settable sysfs attributes more consistent
PCI devices have three settable boolean attributes, enable,
broken_parity_status, and msi_bus.
The store functions for these would silently interpret "0x01" as false,
"1llogical" as true, and "true" would be (silently!) ignored and do
nothing.
This is inconsistent with typical sysfs handling of settable attributes,
and just plain doesn't make much sense.
So, use strict_strtoul(), which was created for this purpose. The store
functions will treat a value of 0 as false, non-zero as true, and return
-EINVAL for a parse failure.
Additionally, is_enabled_store() and msi_bus_store() return -EPERM if
CAP_SYS_ADMIN is lacking, rather than silently doing nothing. This is more
typical behavior for sysfs attributes that need a capability.
And msi_bus_store() will only print the "forced subordinate bus ..."
warning if the MSI flag was actually forced to a different value.
Signed-off-by: Trent Piepho <xyzzy@speakeasy.org>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2008-11-30 18:10:12 -07:00
|
|
|
unsigned long val;
|
|
|
|
ssize_t result = strict_strtoul(buf, 0, &val);
|
|
|
|
|
|
|
|
if (result < 0)
|
|
|
|
return result;
|
2006-04-29 02:59:08 -06:00
|
|
|
|
|
|
|
/* this can crash the machine when done on the "wrong" device */
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
PCI: Make settable sysfs attributes more consistent
PCI devices have three settable boolean attributes, enable,
broken_parity_status, and msi_bus.
The store functions for these would silently interpret "0x01" as false,
"1llogical" as true, and "true" would be (silently!) ignored and do
nothing.
This is inconsistent with typical sysfs handling of settable attributes,
and just plain doesn't make much sense.
So, use strict_strtoul(), which was created for this purpose. The store
functions will treat a value of 0 as false, non-zero as true, and return
-EINVAL for a parse failure.
Additionally, is_enabled_store() and msi_bus_store() return -EPERM if
CAP_SYS_ADMIN is lacking, rather than silently doing nothing. This is more
typical behavior for sysfs attributes that need a capability.
And msi_bus_store() will only print the "forced subordinate bus ..."
warning if the MSI flag was actually forced to a different value.
Signed-off-by: Trent Piepho <xyzzy@speakeasy.org>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2008-11-30 18:10:12 -07:00
|
|
|
return -EPERM;
|
2006-04-29 02:59:08 -06:00
|
|
|
|
PCI: Make settable sysfs attributes more consistent
PCI devices have three settable boolean attributes, enable,
broken_parity_status, and msi_bus.
The store functions for these would silently interpret "0x01" as false,
"1llogical" as true, and "true" would be (silently!) ignored and do
nothing.
This is inconsistent with typical sysfs handling of settable attributes,
and just plain doesn't make much sense.
So, use strict_strtoul(), which was created for this purpose. The store
functions will treat a value of 0 as false, non-zero as true, and return
-EINVAL for a parse failure.
Additionally, is_enabled_store() and msi_bus_store() return -EPERM if
CAP_SYS_ADMIN is lacking, rather than silently doing nothing. This is more
typical behavior for sysfs attributes that need a capability.
And msi_bus_store() will only print the "forced subordinate bus ..."
warning if the MSI flag was actually forced to a different value.
Signed-off-by: Trent Piepho <xyzzy@speakeasy.org>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2008-11-30 18:10:12 -07:00
|
|
|
if (!val) {
|
PCI: switch pci_{enable,disable}_device() to be nestable
Changes the pci_{enable,disable}_device() functions to work in a
nested basis, so that eg, three calls to enable_device() require three
calls to disable_device().
The reason for this is to simplify PCI drivers for
multi-interface/capability devices. These are devices that cram more
than one interface in a single function. A relevant example of that is
the Wireless [USB] Host Controller Interface (similar to EHCI) [see
http://www.intel.com/technology/comms/wusb/whci.htm].
In these kind of devices, multiple interfaces are accessed through a
single bar and IRQ line. For that, the drivers map only the smallest
area of the bar to access their register banks and use shared IRQ
handlers.
However, because the order at which those drivers load cannot be known
ahead of time, the sequence in which the calls to pci_enable_device()
and pci_disable_device() cannot be predicted. Thus:
1. driverA starts pci_enable_device()
2. driverB starts pci_enable_device()
3. driverA shutdown pci_disable_device()
4. driverB shutdown pci_disable_device()
between steps 3 and 4, driver B would loose access to it's device,
even if it didn't intend to.
By using this modification, the device won't be disabled until all the
callers to enable() have called disable().
This is implemented by replacing 'struct pci_dev->is_enabled' from a
bitfield to an atomic use count. Each caller to enable increments it,
each caller to disable decrements it. When the count increments from 0
to 1, __pci_enable_device() is called to actually enable the
device. When it drops to zero, pci_disable_device() actually does the
disabling.
We keep the backend __pci_enable_device() for pci_default_resume() to
use and also change the sysfs method implementation, so that userspace
enabling/disabling the device doesn't disable it one time too much.
Signed-off-by: Inaky Perez-Gonzalez <inaky@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-11-22 13:40:31 -07:00
|
|
|
if (atomic_read(&pdev->enable_cnt) != 0)
|
|
|
|
pci_disable_device(pdev);
|
|
|
|
else
|
|
|
|
result = -EIO;
|
PCI: Make settable sysfs attributes more consistent
PCI devices have three settable boolean attributes, enable,
broken_parity_status, and msi_bus.
The store functions for these would silently interpret "0x01" as false,
"1llogical" as true, and "true" would be (silently!) ignored and do
nothing.
This is inconsistent with typical sysfs handling of settable attributes,
and just plain doesn't make much sense.
So, use strict_strtoul(), which was created for this purpose. The store
functions will treat a value of 0 as false, non-zero as true, and return
-EINVAL for a parse failure.
Additionally, is_enabled_store() and msi_bus_store() return -EPERM if
CAP_SYS_ADMIN is lacking, rather than silently doing nothing. This is more
typical behavior for sysfs attributes that need a capability.
And msi_bus_store() will only print the "forced subordinate bus ..."
warning if the MSI flag was actually forced to a different value.
Signed-off-by: Trent Piepho <xyzzy@speakeasy.org>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2008-11-30 18:10:12 -07:00
|
|
|
} else
|
PCI: switch pci_{enable,disable}_device() to be nestable
Changes the pci_{enable,disable}_device() functions to work in a
nested basis, so that eg, three calls to enable_device() require three
calls to disable_device().
The reason for this is to simplify PCI drivers for
multi-interface/capability devices. These are devices that cram more
than one interface in a single function. A relevant example of that is
the Wireless [USB] Host Controller Interface (similar to EHCI) [see
http://www.intel.com/technology/comms/wusb/whci.htm].
In these kind of devices, multiple interfaces are accessed through a
single bar and IRQ line. For that, the drivers map only the smallest
area of the bar to access their register banks and use shared IRQ
handlers.
However, because the order at which those drivers load cannot be known
ahead of time, the sequence in which the calls to pci_enable_device()
and pci_disable_device() cannot be predicted. Thus:
1. driverA starts pci_enable_device()
2. driverB starts pci_enable_device()
3. driverA shutdown pci_disable_device()
4. driverB shutdown pci_disable_device()
between steps 3 and 4, driver B would loose access to it's device,
even if it didn't intend to.
By using this modification, the device won't be disabled until all the
callers to enable() have called disable().
This is implemented by replacing 'struct pci_dev->is_enabled' from a
bitfield to an atomic use count. Each caller to enable increments it,
each caller to disable decrements it. When the count increments from 0
to 1, __pci_enable_device() is called to actually enable the
device. When it drops to zero, pci_disable_device() actually does the
disabling.
We keep the backend __pci_enable_device() for pci_default_resume() to
use and also change the sysfs method implementation, so that userspace
enabling/disabling the device doesn't disable it one time too much.
Signed-off-by: Inaky Perez-Gonzalez <inaky@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-11-22 13:40:31 -07:00
|
|
|
result = pci_enable_device(pdev);
|
2006-04-29 02:59:08 -06:00
|
|
|
|
PCI: switch pci_{enable,disable}_device() to be nestable
Changes the pci_{enable,disable}_device() functions to work in a
nested basis, so that eg, three calls to enable_device() require three
calls to disable_device().
The reason for this is to simplify PCI drivers for
multi-interface/capability devices. These are devices that cram more
than one interface in a single function. A relevant example of that is
the Wireless [USB] Host Controller Interface (similar to EHCI) [see
http://www.intel.com/technology/comms/wusb/whci.htm].
In these kind of devices, multiple interfaces are accessed through a
single bar and IRQ line. For that, the drivers map only the smallest
area of the bar to access their register banks and use shared IRQ
handlers.
However, because the order at which those drivers load cannot be known
ahead of time, the sequence in which the calls to pci_enable_device()
and pci_disable_device() cannot be predicted. Thus:
1. driverA starts pci_enable_device()
2. driverB starts pci_enable_device()
3. driverA shutdown pci_disable_device()
4. driverB shutdown pci_disable_device()
between steps 3 and 4, driver B would loose access to it's device,
even if it didn't intend to.
By using this modification, the device won't be disabled until all the
callers to enable() have called disable().
This is implemented by replacing 'struct pci_dev->is_enabled' from a
bitfield to an atomic use count. Each caller to enable increments it,
each caller to disable decrements it. When the count increments from 0
to 1, __pci_enable_device() is called to actually enable the
device. When it drops to zero, pci_disable_device() actually does the
disabling.
We keep the backend __pci_enable_device() for pci_default_resume() to
use and also change the sysfs method implementation, so that userspace
enabling/disabling the device doesn't disable it one time too much.
Signed-off-by: Inaky Perez-Gonzalez <inaky@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-11-22 13:40:31 -07:00
|
|
|
return result < 0 ? result : count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t is_enabled_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct pci_dev *pdev;
|
2006-04-29 02:59:08 -06:00
|
|
|
|
PCI: switch pci_{enable,disable}_device() to be nestable
Changes the pci_{enable,disable}_device() functions to work in a
nested basis, so that eg, three calls to enable_device() require three
calls to disable_device().
The reason for this is to simplify PCI drivers for
multi-interface/capability devices. These are devices that cram more
than one interface in a single function. A relevant example of that is
the Wireless [USB] Host Controller Interface (similar to EHCI) [see
http://www.intel.com/technology/comms/wusb/whci.htm].
In these kind of devices, multiple interfaces are accessed through a
single bar and IRQ line. For that, the drivers map only the smallest
area of the bar to access their register banks and use shared IRQ
handlers.
However, because the order at which those drivers load cannot be known
ahead of time, the sequence in which the calls to pci_enable_device()
and pci_disable_device() cannot be predicted. Thus:
1. driverA starts pci_enable_device()
2. driverB starts pci_enable_device()
3. driverA shutdown pci_disable_device()
4. driverB shutdown pci_disable_device()
between steps 3 and 4, driver B would loose access to it's device,
even if it didn't intend to.
By using this modification, the device won't be disabled until all the
callers to enable() have called disable().
This is implemented by replacing 'struct pci_dev->is_enabled' from a
bitfield to an atomic use count. Each caller to enable increments it,
each caller to disable decrements it. When the count increments from 0
to 1, __pci_enable_device() is called to actually enable the
device. When it drops to zero, pci_disable_device() actually does the
disabling.
We keep the backend __pci_enable_device() for pci_default_resume() to
use and also change the sysfs method implementation, so that userspace
enabling/disabling the device doesn't disable it one time too much.
Signed-off-by: Inaky Perez-Gonzalez <inaky@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-11-22 13:40:31 -07:00
|
|
|
pdev = to_pci_dev (dev);
|
|
|
|
return sprintf (buf, "%u\n", atomic_read(&pdev->enable_cnt));
|
2006-04-29 02:59:08 -06:00
|
|
|
}
|
|
|
|
|
2007-01-28 02:53:40 -07:00
|
|
|
#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
|
|
|
|
|
2006-08-30 23:55:15 -06:00
|
|
|
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);
|
PCI: Make settable sysfs attributes more consistent
PCI devices have three settable boolean attributes, enable,
broken_parity_status, and msi_bus.
The store functions for these would silently interpret "0x01" as false,
"1llogical" as true, and "true" would be (silently!) ignored and do
nothing.
This is inconsistent with typical sysfs handling of settable attributes,
and just plain doesn't make much sense.
So, use strict_strtoul(), which was created for this purpose. The store
functions will treat a value of 0 as false, non-zero as true, and return
-EINVAL for a parse failure.
Additionally, is_enabled_store() and msi_bus_store() return -EPERM if
CAP_SYS_ADMIN is lacking, rather than silently doing nothing. This is more
typical behavior for sysfs attributes that need a capability.
And msi_bus_store() will only print the "forced subordinate bus ..."
warning if the MSI flag was actually forced to a different value.
Signed-off-by: Trent Piepho <xyzzy@speakeasy.org>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2008-11-30 18:10:12 -07:00
|
|
|
unsigned long val;
|
|
|
|
|
|
|
|
if (strict_strtoul(buf, 0, &val) < 0)
|
|
|
|
return -EINVAL;
|
2006-08-30 23:55:15 -06:00
|
|
|
|
|
|
|
/* bad things may happen if the no_msi flag is changed
|
|
|
|
* while some drivers are loaded */
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
PCI: Make settable sysfs attributes more consistent
PCI devices have three settable boolean attributes, enable,
broken_parity_status, and msi_bus.
The store functions for these would silently interpret "0x01" as false,
"1llogical" as true, and "true" would be (silently!) ignored and do
nothing.
This is inconsistent with typical sysfs handling of settable attributes,
and just plain doesn't make much sense.
So, use strict_strtoul(), which was created for this purpose. The store
functions will treat a value of 0 as false, non-zero as true, and return
-EINVAL for a parse failure.
Additionally, is_enabled_store() and msi_bus_store() return -EPERM if
CAP_SYS_ADMIN is lacking, rather than silently doing nothing. This is more
typical behavior for sysfs attributes that need a capability.
And msi_bus_store() will only print the "forced subordinate bus ..."
warning if the MSI flag was actually forced to a different value.
Signed-off-by: Trent Piepho <xyzzy@speakeasy.org>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2008-11-30 18:10:12 -07:00
|
|
|
return -EPERM;
|
2006-08-30 23:55:15 -06:00
|
|
|
|
PCI: Make settable sysfs attributes more consistent
PCI devices have three settable boolean attributes, enable,
broken_parity_status, and msi_bus.
The store functions for these would silently interpret "0x01" as false,
"1llogical" as true, and "true" would be (silently!) ignored and do
nothing.
This is inconsistent with typical sysfs handling of settable attributes,
and just plain doesn't make much sense.
So, use strict_strtoul(), which was created for this purpose. The store
functions will treat a value of 0 as false, non-zero as true, and return
-EINVAL for a parse failure.
Additionally, is_enabled_store() and msi_bus_store() return -EPERM if
CAP_SYS_ADMIN is lacking, rather than silently doing nothing. This is more
typical behavior for sysfs attributes that need a capability.
And msi_bus_store() will only print the "forced subordinate bus ..."
warning if the MSI flag was actually forced to a different value.
Signed-off-by: Trent Piepho <xyzzy@speakeasy.org>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2008-11-30 18:10:12 -07:00
|
|
|
/* Maybe pci devices without subordinate busses shouldn't even have this
|
|
|
|
* attribute in the first place? */
|
2006-08-30 23:55:15 -06:00
|
|
|
if (!pdev->subordinate)
|
|
|
|
return count;
|
|
|
|
|
PCI: Make settable sysfs attributes more consistent
PCI devices have three settable boolean attributes, enable,
broken_parity_status, and msi_bus.
The store functions for these would silently interpret "0x01" as false,
"1llogical" as true, and "true" would be (silently!) ignored and do
nothing.
This is inconsistent with typical sysfs handling of settable attributes,
and just plain doesn't make much sense.
So, use strict_strtoul(), which was created for this purpose. The store
functions will treat a value of 0 as false, non-zero as true, and return
-EINVAL for a parse failure.
Additionally, is_enabled_store() and msi_bus_store() return -EPERM if
CAP_SYS_ADMIN is lacking, rather than silently doing nothing. This is more
typical behavior for sysfs attributes that need a capability.
And msi_bus_store() will only print the "forced subordinate bus ..."
warning if the MSI flag was actually forced to a different value.
Signed-off-by: Trent Piepho <xyzzy@speakeasy.org>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2008-11-30 18:10:12 -07:00
|
|
|
/* 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;
|
2006-08-30 23:55:15 -06:00
|
|
|
|
PCI: Make settable sysfs attributes more consistent
PCI devices have three settable boolean attributes, enable,
broken_parity_status, and msi_bus.
The store functions for these would silently interpret "0x01" as false,
"1llogical" as true, and "true" would be (silently!) ignored and do
nothing.
This is inconsistent with typical sysfs handling of settable attributes,
and just plain doesn't make much sense.
So, use strict_strtoul(), which was created for this purpose. The store
functions will treat a value of 0 as false, non-zero as true, and return
-EINVAL for a parse failure.
Additionally, is_enabled_store() and msi_bus_store() return -EPERM if
CAP_SYS_ADMIN is lacking, rather than silently doing nothing. This is more
typical behavior for sysfs attributes that need a capability.
And msi_bus_store() will only print the "forced subordinate bus ..."
warning if the MSI flag was actually forced to a different value.
Signed-off-by: Trent Piepho <xyzzy@speakeasy.org>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2008-11-30 18:10:12 -07:00
|
|
|
dev_warn(&pdev->dev, "forced subordinate bus to%s support MSI,"
|
|
|
|
" bad things could happen\n", val ? "" : " not");
|
2006-08-30 23:55:15 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
2005-05-05 12:57:25 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
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),
|
2008-04-08 12:43:03 -06:00
|
|
|
__ATTR_RO(local_cpulist),
|
2005-05-05 12:57:25 -06:00
|
|
|
__ATTR_RO(modalias),
|
2007-01-28 02:53:40 -07:00
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
__ATTR_RO(numa_node),
|
|
|
|
#endif
|
2006-04-29 02:59:08 -06:00
|
|
|
__ATTR(enable, 0600, is_enabled_show, is_enabled_store),
|
2006-06-14 17:59:48 -06:00
|
|
|
__ATTR(broken_parity_status,(S_IRUGO|S_IWUSR),
|
|
|
|
broken_parity_status_show,broken_parity_status_store),
|
2006-08-30 23:55:15 -06:00
|
|
|
__ATTR(msi_bus, 0644, msi_bus_show, msi_bus_store),
|
2005-04-16 16:20:36 -06:00
|
|
|
__ATTR_NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static ssize_t
|
2007-06-08 23:57:22 -06:00
|
|
|
pci_read_config(struct kobject *kobj, struct bin_attribute *bin_attr,
|
|
|
|
char *buf, loff_t off, size_t count)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj));
|
|
|
|
unsigned int size = 64;
|
|
|
|
loff_t init_off = off;
|
2005-04-07 23:53:31 -06:00
|
|
|
u8 *data = (u8*) buf;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Several chips lock up trying to read undefined config space */
|
|
|
|
if (capable(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;
|
|
|
|
}
|
|
|
|
|
2005-04-07 23:53:31 -06:00
|
|
|
if ((off & 1) && size) {
|
|
|
|
u8 val;
|
2005-09-27 02:21:55 -06:00
|
|
|
pci_user_read_config_byte(dev, off, &val);
|
2005-04-07 23:53:31 -06:00
|
|
|
data[off - init_off] = val;
|
2005-04-16 16:20:36 -06:00
|
|
|
off++;
|
2005-04-07 23:53:31 -06:00
|
|
|
size--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((off & 3) && size > 2) {
|
|
|
|
u16 val;
|
2005-09-27 02:21:55 -06:00
|
|
|
pci_user_read_config_word(dev, off, &val);
|
2005-04-07 23:53:31 -06:00
|
|
|
data[off - init_off] = val & 0xff;
|
|
|
|
data[off - init_off + 1] = (val >> 8) & 0xff;
|
|
|
|
off += 2;
|
|
|
|
size -= 2;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
while (size > 3) {
|
2005-04-07 23:53:31 -06:00
|
|
|
u32 val;
|
2005-09-27 02:21:55 -06:00
|
|
|
pci_user_read_config_dword(dev, off, &val);
|
2005-04-07 23:53:31 -06:00
|
|
|
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;
|
2005-04-16 16:20:36 -06:00
|
|
|
off += 4;
|
|
|
|
size -= 4;
|
|
|
|
}
|
|
|
|
|
2005-04-07 23:53:31 -06:00
|
|
|
if (size >= 2) {
|
|
|
|
u16 val;
|
2005-09-27 02:21:55 -06:00
|
|
|
pci_user_read_config_word(dev, off, &val);
|
2005-04-07 23:53:31 -06:00
|
|
|
data[off - init_off] = val & 0xff;
|
|
|
|
data[off - init_off + 1] = (val >> 8) & 0xff;
|
|
|
|
off += 2;
|
|
|
|
size -= 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (size > 0) {
|
|
|
|
u8 val;
|
2005-09-27 02:21:55 -06:00
|
|
|
pci_user_read_config_byte(dev, off, &val);
|
2005-04-07 23:53:31 -06:00
|
|
|
data[off - init_off] = val;
|
2005-04-16 16:20:36 -06:00
|
|
|
off++;
|
|
|
|
--size;
|
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
2007-06-08 23:57:22 -06:00
|
|
|
pci_write_config(struct kobject *kobj, struct bin_attribute *bin_attr,
|
|
|
|
char *buf, loff_t off, size_t count)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj));
|
|
|
|
unsigned int size = count;
|
|
|
|
loff_t init_off = off;
|
2005-04-07 23:53:31 -06:00
|
|
|
u8 *data = (u8*) buf;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (off > dev->cfg_size)
|
|
|
|
return 0;
|
|
|
|
if (off + count > dev->cfg_size) {
|
|
|
|
size = dev->cfg_size - off;
|
|
|
|
count = size;
|
|
|
|
}
|
2005-04-07 23:53:31 -06:00
|
|
|
|
|
|
|
if ((off & 1) && size) {
|
2005-09-27 02:21:55 -06:00
|
|
|
pci_user_write_config_byte(dev, off, data[off - init_off]);
|
2005-04-16 16:20:36 -06:00
|
|
|
off++;
|
2005-04-07 23:53:31 -06:00
|
|
|
size--;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2005-04-07 23:53:31 -06:00
|
|
|
|
|
|
|
if ((off & 3) && size > 2) {
|
|
|
|
u16 val = data[off - init_off];
|
|
|
|
val |= (u16) data[off - init_off + 1] << 8;
|
2005-09-27 02:21:55 -06:00
|
|
|
pci_user_write_config_word(dev, off, val);
|
2005-04-07 23:53:31 -06:00
|
|
|
off += 2;
|
|
|
|
size -= 2;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
while (size > 3) {
|
2005-04-07 23:53:31 -06:00
|
|
|
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;
|
2005-09-27 02:21:55 -06:00
|
|
|
pci_user_write_config_dword(dev, off, val);
|
2005-04-16 16:20:36 -06:00
|
|
|
off += 4;
|
|
|
|
size -= 4;
|
|
|
|
}
|
2005-04-07 23:53:31 -06:00
|
|
|
|
|
|
|
if (size >= 2) {
|
|
|
|
u16 val = data[off - init_off];
|
|
|
|
val |= (u16) data[off - init_off + 1] << 8;
|
2005-09-27 02:21:55 -06:00
|
|
|
pci_user_write_config_word(dev, off, val);
|
2005-04-07 23:53:31 -06:00
|
|
|
off += 2;
|
|
|
|
size -= 2;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-04-07 23:53:31 -06:00
|
|
|
if (size) {
|
2005-09-27 02:21:55 -06:00
|
|
|
pci_user_write_config_byte(dev, off, data[off - init_off]);
|
2005-04-16 16:20:36 -06:00
|
|
|
off++;
|
|
|
|
--size;
|
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2008-03-05 09:52:39 -07:00
|
|
|
static ssize_t
|
2008-12-18 10:17:16 -07:00
|
|
|
read_vpd_attr(struct kobject *kobj, struct bin_attribute *bin_attr,
|
|
|
|
char *buf, loff_t off, size_t count)
|
2008-03-05 09:52:39 -07:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2008-12-18 10:17:16 -07:00
|
|
|
return pci_read_vpd(dev, off, count, buf);
|
2008-03-05 09:52:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
2008-12-18 10:17:16 -07:00
|
|
|
write_vpd_attr(struct kobject *kobj, struct bin_attribute *bin_attr,
|
|
|
|
char *buf, loff_t off, size_t count)
|
2008-03-05 09:52:39 -07:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2008-12-18 10:17:16 -07:00
|
|
|
return pci_write_vpd(dev, off, count, buf);
|
2008-03-05 09:52:39 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef HAVE_PCI_LEGACY
|
|
|
|
/**
|
|
|
|
* pci_read_legacy_io - read byte(s) from legacy I/O port space
|
|
|
|
* @kobj: kobject corresponding to file to read from
|
|
|
|
* @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).
|
|
|
|
*/
|
2008-10-03 03:49:32 -06:00
|
|
|
static ssize_t
|
2007-06-08 23:57:22 -06:00
|
|
|
pci_read_legacy_io(struct kobject *kobj, struct bin_attribute *bin_attr,
|
|
|
|
char *buf, loff_t off, size_t count)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct pci_bus *bus = to_pci_bus(container_of(kobj,
|
2007-05-22 20:47:54 -06:00
|
|
|
struct device,
|
2005-04-16 16:20:36 -06:00
|
|
|
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
|
|
|
|
* @kobj: kobject corresponding to file to read from
|
|
|
|
* @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).
|
|
|
|
*/
|
2008-10-03 03:49:32 -06:00
|
|
|
static ssize_t
|
2007-06-08 23:57:22 -06:00
|
|
|
pci_write_legacy_io(struct kobject *kobj, struct bin_attribute *bin_attr,
|
|
|
|
char *buf, loff_t off, size_t count)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct pci_bus *bus = to_pci_bus(container_of(kobj,
|
2007-05-22 20:47:54 -06:00
|
|
|
struct device,
|
2005-04-16 16:20:36 -06:00
|
|
|
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
|
|
|
|
* @kobj: kobject corresponding to device to be mapped
|
|
|
|
* @attr: struct bin_attribute for this file
|
|
|
|
* @vma: struct vm_area_struct passed to mmap
|
|
|
|
*
|
2008-10-03 03:49:32 -06:00
|
|
|
* Uses an arch specific callback, pci_mmap_legacy_mem_page_range, to mmap
|
2005-04-16 16:20:36 -06:00
|
|
|
* legacy memory space (first meg of bus space) into application virtual
|
|
|
|
* memory space.
|
|
|
|
*/
|
2008-10-03 03:49:32 -06:00
|
|
|
static int
|
2005-04-16 16:20:36 -06:00
|
|
|
pci_mmap_legacy_mem(struct kobject *kobj, struct bin_attribute *attr,
|
|
|
|
struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
struct pci_bus *bus = to_pci_bus(container_of(kobj,
|
2007-05-22 20:47:54 -06:00
|
|
|
struct device,
|
2005-04-16 16:20:36 -06:00
|
|
|
kobj));
|
|
|
|
|
2008-10-03 03:49:32 -06:00
|
|
|
return pci_mmap_legacy_page_range(bus, vma, pci_mmap_mem);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pci_mmap_legacy_io - map legacy PCI IO into user memory space
|
|
|
|
* @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 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_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;
|
|
|
|
|
|
|
|
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;
|
|
|
|
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;
|
|
|
|
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;
|
|
|
|
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 */
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
#endif /* HAVE_PCI_LEGACY */
|
|
|
|
|
|
|
|
#ifdef HAVE_PCI_MMAP
|
2008-10-02 19:52:51 -06:00
|
|
|
|
2008-10-24 11:32:33 -06:00
|
|
|
int pci_mmap_fits(struct pci_dev *pdev, int resno, struct vm_area_struct *vma)
|
2008-10-02 19:52:51 -06:00
|
|
|
{
|
|
|
|
unsigned long nr, start, size;
|
|
|
|
|
|
|
|
nr = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
|
|
|
|
start = vma->vm_pgoff;
|
2008-11-03 15:41:16 -07:00
|
|
|
size = ((pci_resource_len(pdev, resno) - 1) >> PAGE_SHIFT) + 1;
|
2008-10-02 19:52:51 -06:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* 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
|
2008-03-18 18:00:22 -06:00
|
|
|
* @write_combine: 1 for write_combine mapping
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* 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,
|
2008-03-18 18:00:22 -06:00
|
|
|
struct vm_area_struct *vma, int write_combine)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct pci_dev *pdev = to_pci_dev(container_of(kobj,
|
|
|
|
struct device, kobj));
|
|
|
|
struct resource *res = (struct resource *)attr->private;
|
|
|
|
enum pci_mmap_state mmap_type;
|
2006-06-12 18:06:02 -06:00
|
|
|
resource_size_t start, end;
|
2005-05-13 01:44:10 -06:00
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-05-13 01:44:10 -06:00
|
|
|
for (i = 0; i < PCI_ROM_RESOURCE; i++)
|
|
|
|
if (res == &pdev->resource[i])
|
|
|
|
break;
|
|
|
|
if (i >= PCI_ROM_RESOURCE)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2008-10-02 19:52:51 -06:00
|
|
|
if (!pci_mmap_fits(pdev, i, vma))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-05-13 01:44:10 -06:00
|
|
|
/* 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;
|
2005-04-16 16:20:36 -06:00
|
|
|
mmap_type = res->flags & IORESOURCE_MEM ? pci_mmap_mem : pci_mmap_io;
|
|
|
|
|
2008-10-22 20:55:31 -06:00
|
|
|
if (res->flags & IORESOURCE_MEM && iomem_is_exclusive(start))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-03-18 18:00:22 -06:00
|
|
|
return pci_mmap_page_range(pdev, vma, mmap_type, write_combine);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
pci_mmap_resource_uc(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 kobject *kobj, struct bin_attribute *attr,
|
|
|
|
struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
return pci_mmap_resource(kobj, attr, vma, 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-08-28 12:43:25 -06:00
|
|
|
/**
|
|
|
|
* pci_remove_resource_files - cleanup resource files
|
|
|
|
* @dev: dev to cleanup
|
|
|
|
*
|
|
|
|
* If we created resource files for @dev, 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);
|
|
|
|
}
|
2008-03-18 18:00:22 -06:00
|
|
|
|
|
|
|
res_attr = pdev->res_attr_wc[i];
|
|
|
|
if (res_attr) {
|
|
|
|
sysfs_remove_bin_file(&pdev->dev.kobj, res_attr);
|
|
|
|
kfree(res_attr);
|
|
|
|
}
|
2006-08-28 12:43:25 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-03-18 18:00:22 -06:00
|
|
|
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);
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* pci_create_resource_files - create resource files in sysfs for @dev
|
|
|
|
* @dev: dev in question
|
|
|
|
*
|
|
|
|
* Walk the resources in @dev creating files for each resource available.
|
|
|
|
*/
|
2006-08-28 12:43:25 -06:00
|
|
|
static int pci_create_resource_files(struct pci_dev *pdev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int i;
|
2006-08-28 12:43:25 -06:00
|
|
|
int retval;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
2008-03-18 18:00:22 -06:00
|
|
|
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;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
2006-08-28 12:43:25 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
#else /* !HAVE_PCI_MMAP */
|
2006-08-28 12:43:25 -06:00
|
|
|
static inline int pci_create_resource_files(struct pci_dev *dev) { return 0; }
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline void 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
|
|
|
|
* @kobj: kernel object handle
|
|
|
|
* @buf: user input
|
|
|
|
* @off: file offset
|
|
|
|
* @count: number of byte in input
|
|
|
|
*
|
|
|
|
* writing anything except 0 enables it
|
|
|
|
*/
|
|
|
|
static ssize_t
|
2007-06-08 23:57:22 -06:00
|
|
|
pci_write_rom(struct kobject *kobj, struct bin_attribute *bin_attr,
|
|
|
|
char *buf, loff_t off, size_t count)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
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
|
|
|
|
* @kobj: kernel object handle
|
|
|
|
* @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
|
2007-06-08 23:57:22 -06:00
|
|
|
pci_read_rom(struct kobject *kobj, struct bin_attribute *bin_attr,
|
|
|
|
char *buf, loff_t off, size_t count)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
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)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
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,
|
|
|
|
},
|
2008-10-13 05:18:07 -06:00
|
|
|
.size = PCI_CFG_SPACE_SIZE,
|
2005-04-16 16:20:36 -06:00
|
|
|
.read = pci_read_config,
|
|
|
|
.write = pci_write_config,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct bin_attribute pcie_config_attr = {
|
|
|
|
.attr = {
|
|
|
|
.name = "config",
|
|
|
|
.mode = S_IRUGO | S_IWUSR,
|
|
|
|
},
|
2008-10-13 05:18:07 -06:00
|
|
|
.size = PCI_CFG_SPACE_EXP_SIZE,
|
2005-04-16 16:20:36 -06:00
|
|
|
.read = pci_read_config,
|
|
|
|
.write = pci_write_config,
|
|
|
|
};
|
|
|
|
|
2007-05-07 20:03:08 -06:00
|
|
|
int __attribute__ ((weak)) pcibios_add_platform_entries(struct pci_dev *dev)
|
2007-05-07 20:03:07 -06:00
|
|
|
{
|
2007-05-07 20:03:08 -06:00
|
|
|
return 0;
|
2007-05-07 20:03:07 -06:00
|
|
|
}
|
|
|
|
|
2008-10-13 06:01:00 -06:00
|
|
|
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;
|
|
|
|
|
|
|
|
attr->size = dev->vpd->len;
|
|
|
|
attr->attr.name = "vpd";
|
|
|
|
attr->attr.mode = S_IRUSR | S_IWUSR;
|
2008-12-18 10:17:16 -07:00
|
|
|
attr->read = read_vpd_attr;
|
|
|
|
attr->write = write_vpd_attr;
|
2008-10-13 06:01:00 -06:00
|
|
|
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);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-28 12:43:25 -06:00
|
|
|
int __must_check pci_create_sysfs_dev_files (struct pci_dev *pdev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-08-28 12:43:25 -06:00
|
|
|
int retval;
|
2008-10-13 06:01:00 -06:00
|
|
|
int rom_size = 0;
|
|
|
|
struct bin_attribute *attr;
|
2006-08-28 12:43:25 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!sysfs_initialized)
|
|
|
|
return -EACCES;
|
|
|
|
|
2008-10-13 05:18:07 -06:00
|
|
|
if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
|
2006-08-28 12:43:25 -06:00
|
|
|
retval = sysfs_create_bin_file(&pdev->dev.kobj, &pci_config_attr);
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
2006-08-28 12:43:25 -06:00
|
|
|
retval = sysfs_create_bin_file(&pdev->dev.kobj, &pcie_config_attr);
|
|
|
|
if (retval)
|
|
|
|
goto err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-08-28 12:43:25 -06:00
|
|
|
retval = pci_create_resource_files(pdev);
|
|
|
|
if (retval)
|
2008-10-13 06:01:00 -06:00
|
|
|
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;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* If the device has a ROM, try to expose it in sysfs. */
|
2008-10-13 06:01:00 -06:00
|
|
|
if (rom_size) {
|
2008-03-05 09:52:39 -07:00
|
|
|
attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
|
2008-10-13 06:01:00 -06:00
|
|
|
if (!attr) {
|
2006-08-28 12:43:25 -06:00
|
|
|
retval = -ENOMEM;
|
2007-04-17 21:34:12 -06:00
|
|
|
goto err_resource_files;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-10-13 06:01:00 -06:00
|
|
|
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;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-10-13 06:01:00 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* add platform-specific attributes */
|
2008-10-13 06:01:00 -06:00
|
|
|
retval = pcibios_add_platform_entries(pdev);
|
|
|
|
if (retval)
|
2007-05-07 20:03:08 -06:00
|
|
|
goto err_rom_file;
|
2006-08-28 12:43:25 -06:00
|
|
|
|
2008-10-13 06:01:00 -06:00
|
|
|
/* add sysfs entries for various capabilities */
|
|
|
|
retval = pci_create_capabilities_sysfs(pdev);
|
|
|
|
if (retval)
|
|
|
|
goto err_rom_file;
|
PCI: add PCI Express ASPM support
PCI Express ASPM defines a protocol for PCI Express components in the D0
state to reduce Link power by placing their Links into a low power state
and instructing the other end of the Link to do likewise. This
capability allows hardware-autonomous, dynamic Link power reduction
beyond what is achievable by software-only controlled power management.
However, The device should be configured by software appropriately.
Enabling ASPM will save power, but will introduce device latency.
This patch adds ASPM support in Linux. It introduces a global policy for
ASPM, a sysfs file /sys/module/pcie_aspm/parameters/policy can control
it. The interface can be used as a boot option too. Currently we have
below setting:
-default, BIOS default setting
-powersave, highest power saving mode, enable all available ASPM
state and clock power management
-performance, highest performance, disable ASPM and clock power
management
By default, the 'default' policy is used currently.
In my test, power difference between powersave mode and performance mode
is about 1.3w in a system with 3 PCIE links.
Note: some devices might not work well with aspm, either because chipset
issue or device issue. The patch provide API (pci_disable_link_state),
driver can disable ASPM for specific device.
Signed-off-by: Shaohua Li <shaohua.li@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2008-02-24 18:46:41 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
2006-08-28 12:43:25 -06:00
|
|
|
|
2007-05-07 20:03:08 -06:00
|
|
|
err_rom_file:
|
2008-10-13 06:01:00 -06:00
|
|
|
if (rom_size) {
|
2008-03-05 09:52:39 -07:00
|
|
|
sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
|
2008-10-13 06:01:00 -06:00
|
|
|
kfree(pdev->rom_attr);
|
|
|
|
pdev->rom_attr = NULL;
|
|
|
|
}
|
2007-04-17 21:34:12 -06:00
|
|
|
err_resource_files:
|
|
|
|
pci_remove_resource_files(pdev);
|
2008-03-05 09:52:39 -07:00
|
|
|
err_config_file:
|
2008-10-13 05:18:07 -06:00
|
|
|
if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
|
2006-08-28 12:43:25 -06:00
|
|
|
sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr);
|
|
|
|
else
|
|
|
|
sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr);
|
|
|
|
err:
|
|
|
|
return retval;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-10-13 06:01:00 -06:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2008-10-13 06:01:00 -06:00
|
|
|
int rom_size = 0;
|
|
|
|
|
2006-11-10 13:27:48 -07:00
|
|
|
if (!sysfs_initialized)
|
|
|
|
return;
|
|
|
|
|
2008-10-13 06:01:00 -06:00
|
|
|
pci_remove_capabilities_sysfs(pdev);
|
PCI: add PCI Express ASPM support
PCI Express ASPM defines a protocol for PCI Express components in the D0
state to reduce Link power by placing their Links into a low power state
and instructing the other end of the Link to do likewise. This
capability allows hardware-autonomous, dynamic Link power reduction
beyond what is achievable by software-only controlled power management.
However, The device should be configured by software appropriately.
Enabling ASPM will save power, but will introduce device latency.
This patch adds ASPM support in Linux. It introduces a global policy for
ASPM, a sysfs file /sys/module/pcie_aspm/parameters/policy can control
it. The interface can be used as a boot option too. Currently we have
below setting:
-default, BIOS default setting
-powersave, highest power saving mode, enable all available ASPM
state and clock power management
-performance, highest performance, disable ASPM and clock power
management
By default, the 'default' policy is used currently.
In my test, power difference between powersave mode and performance mode
is about 1.3w in a system with 3 PCIE links.
Note: some devices might not work well with aspm, either because chipset
issue or device issue. The patch provide API (pci_disable_link_state),
driver can disable ASPM for specific device.
Signed-off-by: Shaohua Li <shaohua.li@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2008-02-24 18:46:41 -07:00
|
|
|
|
2008-10-13 05:18:07 -06:00
|
|
|
if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
|
2005-04-16 16:20:36 -06:00
|
|
|
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);
|
|
|
|
|
2008-10-13 06:01:00 -06:00
|
|
|
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);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init pci_sysfs_init(void)
|
|
|
|
{
|
|
|
|
struct pci_dev *pdev = NULL;
|
2006-08-28 12:43:25 -06:00
|
|
|
int retval;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
sysfs_initialized = 1;
|
2006-08-28 12:43:25 -06:00
|
|
|
for_each_pci_dev(pdev) {
|
|
|
|
retval = pci_create_sysfs_dev_files(pdev);
|
2007-11-20 00:41:16 -07:00
|
|
|
if (retval) {
|
|
|
|
pci_dev_put(pdev);
|
2006-08-28 12:43:25 -06:00
|
|
|
return retval;
|
2007-11-20 00:41:16 -07:00
|
|
|
}
|
2006-08-28 12:43:25 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-03-24 12:03:32 -06:00
|
|
|
late_initcall(pci_sysfs_init);
|