[linux-2.6-block.git] / drivers / pci / pcie / portdrv_core.c

/*
 * File:	portdrv_core.c
 * Purpose:	PCI Express Port Bus Driver's Core Functions
 *
 * Copyright (C) 2004 Intel
 * Copyright (C) Tom Long Nguyen (tom.l.nguyen@intel.com)
 */

#include <linux/module.h>
#include <linux/pci.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/pm.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/pcieport_if.h>

#include "../pci.h"
#include "portdrv.h"

/**
 * release_pcie_device - free PCI Express port service device structure
 * @dev: Port service device to release
 *
 * Invoked automatically when device is being removed in response to
 * device_unregister(dev).  Release all resources being claimed.
 */
static void release_pcie_device(struct device *dev)
{
	kfree(to_pcie_device(dev));
}

/**
 * pcie_port_msix_add_entry - add entry to given array of MSI-X entries
 * @entries: Array of MSI-X entries
 * @new_entry: Index of the entry to add to the array
 * @nr_entries: Number of entries aleady in the array
 *
 * Return value: Position of the added entry in the array
 */
static int pcie_port_msix_add_entry(
	struct msix_entry *entries, int new_entry, int nr_entries)
{
	int j;

	for (j = 0; j < nr_entries; j++)
		if (entries[j].entry == new_entry)
			return j;

	entries[j].entry = new_entry;
	return j;
}

/**
 * pcie_port_enable_msix - try to set up MSI-X as interrupt mode for given port
 * @dev: PCI Express port to handle
 * @vectors: Array of interrupt vectors to populate
 * @mask: Bitmask of port capabilities returned by get_port_device_capability()
 *
 * Return value: 0 on success, error code on failure
 */
static int pcie_port_enable_msix(struct pci_dev *dev, int *vectors, int mask)
{
	struct msix_entry *msix_entries;
	int idx[PCIE_PORT_DEVICE_MAXSERVICES];
	int nr_entries, status, pos, i, nvec;
	u16 reg16;
	u32 reg32;

	nr_entries = pci_msix_table_size(dev);
	if (!nr_entries)
		return -EINVAL;
	if (nr_entries > PCIE_PORT_MAX_MSIX_ENTRIES)
		nr_entries = PCIE_PORT_MAX_MSIX_ENTRIES;

	msix_entries = kzalloc(sizeof(*msix_entries) * nr_entries, GFP_KERNEL);
	if (!msix_entries)
		return -ENOMEM;

	/*
	 * Allocate as many entries as the port wants, so that we can check
	 * which of them will be useful.  Moreover, if nr_entries is correctly
	 * equal to the number of entries this port actually uses, we'll happily
	 * go through without any tricks.
	 */
	for (i = 0; i < nr_entries; i++)
		msix_entries[i].entry = i;

	status = pci_enable_msix(dev, msix_entries, nr_entries);
	if (status)
		goto Exit;

	for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
		idx[i] = -1;
	status = -EIO;
	nvec = 0;

	if (mask & (PCIE_PORT_SERVICE_PME | PCIE_PORT_SERVICE_HP)) {
		int entry;

		/*
		 * The code below follows the PCI Express Base Specification 2.0
		 * stating in Section 6.1.6 that "PME and Hot-Plug Event
		 * interrupts (when both are implemented) always share the same
		 * MSI or MSI-X vector, as indicated by the Interrupt Message
		 * Number field in the PCI Express Capabilities register", where
		 * according to Section 7.8.2 of the specification "For MSI-X,
		 * the value in this field indicates which MSI-X Table entry is
		 * used to generate the interrupt message."
		 */
		pos = pci_pcie_cap(dev);
		pci_read_config_word(dev, pos + PCI_EXP_FLAGS, &reg16);
		entry = (reg16 & PCI_EXP_FLAGS_IRQ) >> 9;
		if (entry >= nr_entries)
			goto Error;

		i = pcie_port_msix_add_entry(msix_entries, entry, nvec);
		if (i == nvec)
			nvec++;

		idx[PCIE_PORT_SERVICE_PME_SHIFT] = i;
		idx[PCIE_PORT_SERVICE_HP_SHIFT] = i;
	}

	if (mask & PCIE_PORT_SERVICE_AER) {
		int entry;

		/*
		 * The code below follows Section 7.10.10 of the PCI Express
		 * Base Specification 2.0 stating that bits 31-27 of the Root
		 * Error Status Register contain a value indicating which of the
		 * MSI/MSI-X vectors assigned to the port is going to be used
		 * for AER, where "For MSI-X, the value in this register
		 * indicates which MSI-X Table entry is used to generate the
		 * interrupt message."
		 */
		pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
		pci_read_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, &reg32);
		entry = reg32 >> 27;
		if (entry >= nr_entries)
			goto Error;

		i = pcie_port_msix_add_entry(msix_entries, entry, nvec);
		if (i == nvec)
			nvec++;

		idx[PCIE_PORT_SERVICE_AER_SHIFT] = i;
	}

	/*
	 * If nvec is equal to the allocated number of entries, we can just use
	 * what we have.  Otherwise, the port has some extra entries not for the
	 * services we know and we need to work around that.
	 */
	if (nvec == nr_entries) {
		status = 0;
	} else {
		/* Drop the temporary MSI-X setup */
		pci_disable_msix(dev);

		/* Now allocate the MSI-X vectors for real */
		status = pci_enable_msix(dev, msix_entries, nvec);
		if (status)
			goto Exit;
	}

	for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
		vectors[i] = idx[i] >= 0 ? msix_entries[idx[i]].vector : -1;

 Exit:
	kfree(msix_entries);
	return status;

 Error:
	pci_disable_msix(dev);
	goto Exit;
}

/**
 * init_service_irqs - initialize irqs for PCI Express port services
 * @dev: PCI Express port to handle
 * @irqs: Array of irqs to populate
 * @mask: Bitmask of port capabilities returned by get_port_device_capability()
 *
 * Return value: Interrupt mode associated with the port
 */
static int init_service_irqs(struct pci_dev *dev, int *irqs, int mask)
{
	int i, irq;

	/* Try to use MSI-X if supported */
	if (!pcie_port_enable_msix(dev, irqs, mask))
		return 0;
	/* We're not going to use MSI-X, so try MSI and fall back to INTx */
	irq = -1;
	if (!pci_enable_msi(dev) || dev->pin)
		irq = dev->irq;

	for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
		irqs[i] = irq;
	irqs[PCIE_PORT_SERVICE_VC_SHIFT] = -1;

	if (irq < 0)
		return -ENODEV;
	return 0;
}

static void cleanup_service_irqs(struct pci_dev *dev)
{
	if (dev->msix_enabled)
		pci_disable_msix(dev);
	else if (dev->msi_enabled)
		pci_disable_msi(dev);
}

/**
 * get_port_device_capability - discover capabilities of a PCI Express port
 * @dev: PCI Express port to examine
 *
 * The capabilities are read from the port's PCI Express configuration registers
 * as described in PCI Express Base Specification 1.0a sections 7.8.2, 7.8.9 and
 * 7.9 - 7.11.
 *
 * Return value: Bitmask of discovered port capabilities
 */
static int get_port_device_capability(struct pci_dev *dev)
{
	int services = 0, pos;
	u16 reg16;
	u32 reg32;

	pos = pci_pcie_cap(dev);
	pci_read_config_word(dev, pos + PCI_EXP_FLAGS, &reg16);
	/* Hot-Plug Capable */
	if (reg16 & PCI_EXP_FLAGS_SLOT) {
		pci_read_config_dword(dev, pos + PCI_EXP_SLTCAP, &reg32);
		if (reg32 & PCI_EXP_SLTCAP_HPC)
			services |= PCIE_PORT_SERVICE_HP;
	}
	/* AER capable */
	if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR))
		services |= PCIE_PORT_SERVICE_AER;
	/* VC support */
	if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_VC))
		services |= PCIE_PORT_SERVICE_VC;
	/* Root ports are capable of generating PME too */
	if (dev->pcie_type == PCI_EXP_TYPE_ROOT_PORT)
		services |= PCIE_PORT_SERVICE_PME;

	return services;
}

/**
 * pcie_device_init - allocate and initialize PCI Express port service device
 * @pdev: PCI Express port to associate the service device with
 * @service: Type of service to associate with the service device
 * @irq: Interrupt vector to associate with the service device
 */
static int pcie_device_init(struct pci_dev *pdev, int service, int irq)
{
	int retval;
	struct pcie_device *pcie;
	struct device *device;

	pcie = kzalloc(sizeof(*pcie), GFP_KERNEL);
	if (!pcie)
		return -ENOMEM;
	pcie->port = pdev;
	pcie->irq = irq;
	pcie->service = service;

	/* Initialize generic device interface */
	device = &pcie->device;
	device->bus = &pcie_port_bus_type;
	device->release = release_pcie_device;	/* callback to free pcie dev */
	dev_set_name(device, "%s:pcie%02x",
		     pci_name(pdev),
		     get_descriptor_id(pdev->pcie_type, service));
	device->parent = &pdev->dev;

	retval = device_register(device);
	if (retval)
		kfree(pcie);
	else
		get_device(device);
	return retval;
}

/**
 * pcie_port_device_register - register PCI Express port
 * @dev: PCI Express port to register
 *
 * Allocate the port extension structure and register services associated with
 * the port.
 */
int pcie_port_device_register(struct pci_dev *dev)
{
	int status, capabilities, i, nr_service;
	int irqs[PCIE_PORT_DEVICE_MAXSERVICES];

	/* Get and check PCI Express port services */
	capabilities = get_port_device_capability(dev);
	if (!capabilities)
		return -ENODEV;

	/* Enable PCI Express port device */
	status = pci_enable_device(dev);
	if (status)
		return status;
	pci_set_master(dev);
	/*
	 * Initialize service irqs. Don't use service devices that
	 * require interrupts if there is no way to generate them.
	 */
	status = init_service_irqs(dev, irqs, capabilities);
	if (status) {
		capabilities &= PCIE_PORT_SERVICE_VC;
		if (!capabilities)
			goto error_disable;
	}

	/* Allocate child services if any */
	status = -ENODEV;
	nr_service = 0;
	for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++) {
		int service = 1 << i;
		if (!(capabilities & service))
			continue;
		if (!pcie_device_init(dev, service, irqs[i]))
			nr_service++;
	}
	if (!nr_service)
		goto error_cleanup_irqs;

	return 0;

error_cleanup_irqs:
	cleanup_service_irqs(dev);
error_disable:
	pci_disable_device(dev);
	return status;
}

#ifdef CONFIG_PM
static int suspend_iter(struct device *dev, void *data)
{
	struct pcie_port_service_driver *service_driver;

	if ((dev->bus == &pcie_port_bus_type) && dev->driver) {
		service_driver = to_service_driver(dev->driver);
		if (service_driver->suspend)
			service_driver->suspend(to_pcie_device(dev));
	}
	return 0;
}

/**
 * pcie_port_device_suspend - suspend port services associated with a PCIe port
 * @dev: PCI Express port to handle
 */
int pcie_port_device_suspend(struct device *dev)
{
	return device_for_each_child(dev, NULL, suspend_iter);
}

static int resume_iter(struct device *dev, void *data)
{
	struct pcie_port_service_driver *service_driver;

	if ((dev->bus == &pcie_port_bus_type) &&
	    (dev->driver)) {
		service_driver = to_service_driver(dev->driver);
		if (service_driver->resume)
			service_driver->resume(to_pcie_device(dev));
	}
	return 0;
}

/**
 * pcie_port_device_suspend - resume port services associated with a PCIe port
 * @dev: PCI Express port to handle
 */
int pcie_port_device_resume(struct device *dev)
{
	return device_for_each_child(dev, NULL, resume_iter);
}
#endif /* PM */

static int remove_iter(struct device *dev, void *data)
{
	if (dev->bus == &pcie_port_bus_type) {
		put_device(dev);
		device_unregister(dev);
	}
	return 0;
}

/**
 * pcie_port_device_remove - unregister PCI Express port service devices
 * @dev: PCI Express port the service devices to unregister are associated with
 *
 * Remove PCI Express port service devices associated with given port and
 * disable MSI-X or MSI for the port.
 */
void pcie_port_device_remove(struct pci_dev *dev)
{
	device_for_each_child(&dev->dev, NULL, remove_iter);
	cleanup_service_irqs(dev);
	pci_disable_device(dev);
}

/**
 * pcie_port_probe_service - probe driver for given PCI Express port service
 * @dev: PCI Express port service device to probe against
 *
 * If PCI Express port service driver is registered with
 * pcie_port_service_register(), this function will be called by the driver core
 * whenever match is found between the driver and a port service device.
 */
static int pcie_port_probe_service(struct device *dev)
{
	struct pcie_device *pciedev;
	struct pcie_port_service_driver *driver;
	int status;

	if (!dev || !dev->driver)
		return -ENODEV;

	driver = to_service_driver(dev->driver);
	if (!driver || !driver->probe)
		return -ENODEV;

	pciedev = to_pcie_device(dev);
	status = driver->probe(pciedev);
	if (!status) {
		dev_printk(KERN_DEBUG, dev, "service driver %s loaded\n",
			driver->name);
		get_device(dev);
	}
	return status;
}

/**
 * pcie_port_remove_service - detach driver from given PCI Express port service
 * @dev: PCI Express port service device to handle
 *
 * If PCI Express port service driver is registered with
 * pcie_port_service_register(), this function will be called by the driver core
 * when device_unregister() is called for the port service device associated
 * with the driver.
 */
static int pcie_port_remove_service(struct device *dev)
{
	struct pcie_device *pciedev;
	struct pcie_port_service_driver *driver;

	if (!dev || !dev->driver)
		return 0;

	pciedev = to_pcie_device(dev);
	driver = to_service_driver(dev->driver);
	if (driver && driver->remove) {
		dev_printk(KERN_DEBUG, dev, "unloading service driver %s\n",
			driver->name);
		driver->remove(pciedev);
		put_device(dev);
	}
	return 0;
}

/**
 * pcie_port_shutdown_service - shut down given PCI Express port service
 * @dev: PCI Express port service device to handle
 *
 * If PCI Express port service driver is registered with
 * pcie_port_service_register(), this function will be called by the driver core
 * when device_shutdown() is called for the port service device associated
 * with the driver.
 */
static void pcie_port_shutdown_service(struct device *dev) {}

/**
 * pcie_port_service_register - register PCI Express port service driver
 * @new: PCI Express port service driver to register
 */
int pcie_port_service_register(struct pcie_port_service_driver *new)
{
	new->driver.name = (char *)new->name;
	new->driver.bus = &pcie_port_bus_type;
	new->driver.probe = pcie_port_probe_service;
	new->driver.remove = pcie_port_remove_service;
	new->driver.shutdown = pcie_port_shutdown_service;

	return driver_register(&new->driver);
}
EXPORT_SYMBOL(pcie_port_service_register);

/**
 * pcie_port_service_unregister - unregister PCI Express port service driver
 * @drv: PCI Express port service driver to unregister
 */
void pcie_port_service_unregister(struct pcie_port_service_driver *drv)
{
	driver_unregister(&drv->driver);
}
EXPORT_SYMBOL(pcie_port_service_unregister);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* File: portdrv_core.c
	3	* Purpose: PCI Express Port Bus Driver's Core Functions
	4	*
	5	* Copyright (C) 2004 Intel
	6	* Copyright (C) Tom Long Nguyen (tom.l.nguyen@intel.com)
	7	*/
	8
	9	#include <linux/module.h>
	10	#include <linux/pci.h>
	11	#include <linux/kernel.h>
	12	#include <linux/errno.h>
	13	#include <linux/pm.h>
4e57b681 TS	14	#include <linux/string.h>
4e57b681 TS	15	#include <linux/slab.h>
1da177e4 LT	16	#include <linux/pcieport_if.h>
1da177e4 LT	17
1bf83e55	18	#include "../pci.h"
1da177e4 LT	19	#include "portdrv.h"
1da177e4 LT	20
facf6d16 RW	21	/**
	22	* release_pcie_device - free PCI Express port service device structure
	23	* @dev: Port service device to release
	24	*
	25	* Invoked automatically when device is being removed in response to
	26	* device_unregister(dev). Release all resources being claimed.
1da177e4 LT	27	*/
	28	static void release_pcie_device(struct device *dev)
	29	{
40da4186	30	kfree(to_pcie_device(dev));
1da177e4 LT	31	}
1da177e4 LT	32
b43d4513 RW	33	/**
	34	* pcie_port_msix_add_entry - add entry to given array of MSI-X entries
	35	* @entries: Array of MSI-X entries
	36	* @new_entry: Index of the entry to add to the array
	37	* @nr_entries: Number of entries aleady in the array
	38	*
	39	* Return value: Position of the added entry in the array
	40	*/
	41	static int pcie_port_msix_add_entry(
	42	struct msix_entry *entries, int new_entry, int nr_entries)
	43	{
	44	int j;
	45
	46	for (j = 0; j < nr_entries; j++)
	47	if (entries[j].entry == new_entry)
	48	return j;
	49
	50	entries[j].entry = new_entry;
	51	return j;
	52	}
	53
	54	/**
	55	* pcie_port_enable_msix - try to set up MSI-X as interrupt mode for given port
	56	* @dev: PCI Express port to handle
	57	* @vectors: Array of interrupt vectors to populate
	58	* @mask: Bitmask of port capabilities returned by get_port_device_capability()
	59	*
	60	* Return value: 0 on success, error code on failure
	61	*/
	62	static int pcie_port_enable_msix(struct pci_dev dev, int vectors, int mask)
	63	{
	64	struct msix_entry *msix_entries;
	65	int idx[PCIE_PORT_DEVICE_MAXSERVICES];
	66	int nr_entries, status, pos, i, nvec;
	67	u16 reg16;
	68	u32 reg32;
	69
	70	nr_entries = pci_msix_table_size(dev);
	71	if (!nr_entries)
	72	return -EINVAL;
	73	if (nr_entries > PCIE_PORT_MAX_MSIX_ENTRIES)
	74	nr_entries = PCIE_PORT_MAX_MSIX_ENTRIES;
	75
	76	msix_entries = kzalloc(sizeof(msix_entries) nr_entries, GFP_KERNEL);
	77	if (!msix_entries)
	78	return -ENOMEM;
	79
	80	/*
	81	* Allocate as many entries as the port wants, so that we can check
	82	* which of them will be useful. Moreover, if nr_entries is correctly
	83	* equal to the number of entries this port actually uses, we'll happily
	84	* go through without any tricks.
	85	*/
	86	for (i = 0; i < nr_entries; i++)
	87	msix_entries[i].entry = i;
	88
	89	status = pci_enable_msix(dev, msix_entries, nr_entries);
	90	if (status)
	91	goto Exit;
	92
	93	for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
	94	idx[i] = -1;
	95	status = -EIO;
	96	nvec = 0;
97
98	if (mask & (PCIE_PORT_SERVICE_PME \| PCIE_PORT_SERVICE_HP)) {
99	int entry;
100
101	/*
102	* The code below follows the PCI Express Base Specification 2.0
103	* stating in Section 6.1.6 that "PME and Hot-Plug Event
104	* interrupts (when both are implemented) always share the same
105	* MSI or MSI-X vector, as indicated by the Interrupt Message
106	* Number field in the PCI Express Capabilities register", where
107	* according to Section 7.8.2 of the specification "For MSI-X,
108	* the value in this field indicates which MSI-X Table entry is
109	* used to generate the interrupt message."
110	*/
dba90dfe	111	pos = pci_pcie_cap(dev);
f9f45604 KK	112	pci_read_config_word(dev, pos + PCI_EXP_FLAGS, &reg16);
f9f45604 KK	113	entry = (reg16 & PCI_EXP_FLAGS_IRQ) >> 9;
b43d4513 RW	114	if (entry >= nr_entries)
	115	goto Error;
	116
	117	i = pcie_port_msix_add_entry(msix_entries, entry, nvec);
	118	if (i == nvec)
	119	nvec++;
	120
	121	idx[PCIE_PORT_SERVICE_PME_SHIFT] = i;
	122	idx[PCIE_PORT_SERVICE_HP_SHIFT] = i;
	123	}
	124
	125	if (mask & PCIE_PORT_SERVICE_AER) {
	126	int entry;
	127
	128	/*
	129	* The code below follows Section 7.10.10 of the PCI Express
	130	* Base Specification 2.0 stating that bits 31-27 of the Root
	131	* Error Status Register contain a value indicating which of the
	132	* MSI/MSI-X vectors assigned to the port is going to be used
	133	* for AER, where "For MSI-X, the value in this register
	134	* indicates which MSI-X Table entry is used to generate the
	135	* interrupt message."
	136	*/
	137	pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
	138	pci_read_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, &reg32);
	139	entry = reg32 >> 27;
	140	if (entry >= nr_entries)
	141	goto Error;
	142
	143	i = pcie_port_msix_add_entry(msix_entries, entry, nvec);
	144	if (i == nvec)
	145	nvec++;
	146
	147	idx[PCIE_PORT_SERVICE_AER_SHIFT] = i;
	148	}
	149
	150	/*
	151	* If nvec is equal to the allocated number of entries, we can just use
	152	* what we have. Otherwise, the port has some extra entries not for the
	153	* services we know and we need to work around that.
	154	*/
	155	if (nvec == nr_entries) {
	156	status = 0;
	157	} else {
	158	/* Drop the temporary MSI-X setup */
	159	pci_disable_msix(dev);
	160
	161	/* Now allocate the MSI-X vectors for real */
	162	status = pci_enable_msix(dev, msix_entries, nvec);
	163	if (status)
	164	goto Exit;
	165	}
	166
	167	for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
	168	vectors[i] = idx[i] >= 0 ? msix_entries[idx[i]].vector : -1;
	169
	170	Exit:
	171	kfree(msix_entries);
	172	return status;
	173
	174	Error:
	175	pci_disable_msix(dev);
	176	goto Exit;
	177	}
178
facf6d16	179	/**
dc535178	180	* init_service_irqs - initialize irqs for PCI Express port services
facf6d16	181	* @dev: PCI Express port to handle
dc535178	182	* @irqs: Array of irqs to populate
facf6d16 RW	183	* @mask: Bitmask of port capabilities returned by get_port_device_capability()
	184	*
	185	* Return value: Interrupt mode associated with the port
	186	*/
dc535178	187	static int init_service_irqs(struct pci_dev dev, int irqs, int mask)
1da177e4	188	{
dc535178	189	int i, irq;
90e9cd50	190
b43d4513	191	/* Try to use MSI-X if supported */
dc535178 KK	192	if (!pcie_port_enable_msix(dev, irqs, mask))
dc535178 KK	193	return 0;
b43d4513	194	/* We're not going to use MSI-X, so try MSI and fall back to INTx */
dc535178 KK	195	irq = -1;
	196	if (!pci_enable_msi(dev) \|\| dev->pin)
	197	irq = dev->irq;
b43d4513	198
b43d4513	199	for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
dc535178 KK	200	irqs[i] = irq;
dc535178 KK	201	irqs[PCIE_PORT_SERVICE_VC_SHIFT] = -1;
1da177e4	202
dc535178 KK	203	if (irq < 0)
	204	return -ENODEV;
	205	return 0;
1da177e4 LT	206	}
1da177e4 LT	207
fbb5de70 KK	208	static void cleanup_service_irqs(struct pci_dev *dev)
	209	{
	210	if (dev->msix_enabled)
	211	pci_disable_msix(dev);
	212	else if (dev->msi_enabled)
	213	pci_disable_msi(dev);
	214	}
	215
facf6d16 RW	216	/**
	217	* get_port_device_capability - discover capabilities of a PCI Express port
	218	* @dev: PCI Express port to examine
	219	*
	220	* The capabilities are read from the port's PCI Express configuration registers
	221	* as described in PCI Express Base Specification 1.0a sections 7.8.2, 7.8.9 and
	222	* 7.9 - 7.11.
	223	*
	224	* Return value: Bitmask of discovered port capabilities
	225	*/
1da177e4 LT	226	static int get_port_device_capability(struct pci_dev *dev)
	227	{
	228	int services = 0, pos;
	229	u16 reg16;
	230	u32 reg32;
	231
dba90dfe	232	pos = pci_pcie_cap(dev);
f9f45604	233	pci_read_config_word(dev, pos + PCI_EXP_FLAGS, &reg16);
1da177e4	234	/* Hot-Plug Capable */
f9f45604 KK	235	if (reg16 & PCI_EXP_FLAGS_SLOT) {
	236	pci_read_config_dword(dev, pos + PCI_EXP_SLTCAP, &reg32);
	237	if (reg32 & PCI_EXP_SLTCAP_HPC)
1da177e4	238	services \|= PCIE_PORT_SERVICE_HP;
1bf83e55 RW	239	}
1bf83e55 RW	240	/* AER capable */
0927678f JB	241	if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR))
0927678f JB	242	services \|= PCIE_PORT_SERVICE_AER;
1bf83e55	243	/* VC support */
0927678f JB	244	if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_VC))
0927678f JB	245	services \|= PCIE_PORT_SERVICE_VC;
9e5d0b16 KK	246	/* Root ports are capable of generating PME too */
	247	if (dev->pcie_type == PCI_EXP_TYPE_ROOT_PORT)
	248	services \|= PCIE_PORT_SERVICE_PME;
1da177e4 LT	249
	250	return services;
	251	}
	252
facf6d16	253	/**
52a0f24b KK	254	* pcie_device_init - allocate and initialize PCI Express port service device
	255	* @pdev: PCI Express port to associate the service device with
	256	* @service: Type of service to associate with the service device
facf6d16	257	* @irq: Interrupt vector to associate with the service device
facf6d16	258	*/
52a0f24b	259	static int pcie_device_init(struct pci_dev *pdev, int service, int irq)
1da177e4	260	{
52a0f24b KK	261	int retval;
52a0f24b KK	262	struct pcie_device *pcie;
1da177e4 LT	263	struct device *device;
1da177e4 LT	264
52a0f24b KK	265	pcie = kzalloc(sizeof(*pcie), GFP_KERNEL);
	266	if (!pcie)
	267	return -ENOMEM;
	268	pcie->port = pdev;
	269	pcie->irq = irq;
	270	pcie->service = service;
1da177e4 LT	271
1da177e4 LT	272	/* Initialize generic device interface */
52a0f24b	273	device = &pcie->device;
1da177e4	274	device->bus = &pcie_port_bus_type;
1da177e4	275	device->release = release_pcie_device; /* callback to free pcie dev */
1a927133	276	dev_set_name(device, "%s:pcie%02x",
52a0f24b KK	277	pci_name(pdev),
	278	get_descriptor_id(pdev->pcie_type, service));
	279	device->parent = &pdev->dev;
	280
	281	retval = device_register(device);
	282	if (retval)
	283	kfree(pcie);
	284	else
	285	get_device(device);
	286	return retval;
1da177e4 LT	287	}
1da177e4 LT	288
facf6d16 RW	289	/**
	290	* pcie_port_device_register - register PCI Express port
	291	* @dev: PCI Express port to register
	292	*
	293	* Allocate the port extension structure and register services associated with
	294	* the port.
	295	*/
1da177e4 LT	296	int pcie_port_device_register(struct pci_dev *dev)
1da177e4 LT	297	{
40717c39	298	int status, capabilities, i, nr_service;
dc535178	299	int irqs[PCIE_PORT_DEVICE_MAXSERVICES];
1da177e4	300
40717c39	301	/* Get and check PCI Express port services */
d013598d KK	302	capabilities = get_port_device_capability(dev);
	303	if (!capabilities)
	304	return -ENODEV;
	305
1ce5e830 KK	306	/* Enable PCI Express port device */
	307	status = pci_enable_device(dev);
	308	if (status)
694f88ef	309	return status;
1ce5e830	310	pci_set_master(dev);
dc535178 KK	311	/*
	312	* Initialize service irqs. Don't use service devices that
	313	* require interrupts if there is no way to generate them.
	314	*/
	315	status = init_service_irqs(dev, irqs, capabilities);
	316	if (status) {
	317	capabilities &= PCIE_PORT_SERVICE_VC;
	318	if (!capabilities)
1ce5e830	319	goto error_disable;
f118c0c3	320	}
1da177e4 LT	321
1da177e4 LT	322	/* Allocate child services if any */
40717c39 KK	323	status = -ENODEV;
	324	nr_service = 0;
	325	for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++) {
90e9cd50	326	int service = 1 << i;
90e9cd50 RW	327	if (!(capabilities & service))
90e9cd50 RW	328	continue;
40717c39 KK	329	if (!pcie_device_init(dev, service, irqs[i]))
40717c39 KK	330	nr_service++;
f118c0c3	331	}
40717c39	332	if (!nr_service)
fbb5de70	333	goto error_cleanup_irqs;
40717c39	334
1da177e4	335	return 0;
f118c0c3	336
fbb5de70 KK	337	error_cleanup_irqs:
fbb5de70 KK	338	cleanup_service_irqs(dev);
1ce5e830 KK	339	error_disable:
1ce5e830 KK	340	pci_disable_device(dev);
f118c0c3	341	return status;
1da177e4 LT	342	}
	343
	344	#ifdef CONFIG_PM
d0e2b4a0	345	static int suspend_iter(struct device dev, void data)
1da177e4	346	{
1da177e4	347	struct pcie_port_service_driver *service_driver;
d0e2b4a0	348
40da4186 HS	349	if ((dev->bus == &pcie_port_bus_type) && dev->driver) {
	350	service_driver = to_service_driver(dev->driver);
	351	if (service_driver->suspend)
	352	service_driver->suspend(to_pcie_device(dev));
	353	}
d0e2b4a0	354	return 0;
d0e2b4a0	355	}
1da177e4	356
facf6d16 RW	357	/**
	358	* pcie_port_device_suspend - suspend port services associated with a PCIe port
	359	* @dev: PCI Express port to handle
facf6d16	360	*/
3a3c244c	361	int pcie_port_device_suspend(struct device *dev)
d0e2b4a0	362	{
3a3c244c	363	return device_for_each_child(dev, NULL, suspend_iter);
1da177e4 LT	364	}
1da177e4 LT	365
d0e2b4a0	366	static int resume_iter(struct device dev, void data)
d0e2b4a0	367	{
1da177e4 LT	368	struct pcie_port_service_driver *service_driver;
1da177e4 LT	369
d0e2b4a0	370	if ((dev->bus == &pcie_port_bus_type) &&
	371	(dev->driver)) {
	372	service_driver = to_service_driver(dev->driver);
	373	if (service_driver->resume)
	374	service_driver->resume(to_pcie_device(dev));
1da177e4	375	}
d0e2b4a0	376	return 0;
d0e2b4a0	377	}
1da177e4	378
facf6d16 RW	379	/**
	380	* pcie_port_device_suspend - resume port services associated with a PCIe port
	381	* @dev: PCI Express port to handle
	382	*/
3a3c244c	383	int pcie_port_device_resume(struct device *dev)
d0e2b4a0	384	{
3a3c244c	385	return device_for_each_child(dev, NULL, resume_iter);
1da177e4	386	}
3a3c244c	387	#endif /* PM */
1da177e4	388
d0e2b4a0	389	static int remove_iter(struct device dev, void data)
1da177e4	390	{
d0e2b4a0	391	if (dev->bus == &pcie_port_bus_type) {
ae40582e EB	392	put_device(dev);
ae40582e EB	393	device_unregister(dev);
1da177e4	394	}
d0e2b4a0	395	return 0;
	396	}
	397
facf6d16 RW	398	/**
	399	* pcie_port_device_remove - unregister PCI Express port service devices
	400	* @dev: PCI Express port the service devices to unregister are associated with
	401	*
	402	* Remove PCI Express port service devices associated with given port and
	403	* disable MSI-X or MSI for the port.
	404	*/
d0e2b4a0	405	void pcie_port_device_remove(struct pci_dev *dev)
d0e2b4a0	406	{
ae40582e	407	device_for_each_child(&dev->dev, NULL, remove_iter);
fbb5de70	408	cleanup_service_irqs(dev);
dc535178	409	pci_disable_device(dev);
1da177e4 LT	410	}
1da177e4 LT	411
d9347371 RW	412	/**
	413	* pcie_port_probe_service - probe driver for given PCI Express port service
	414	* @dev: PCI Express port service device to probe against
	415	*
	416	* If PCI Express port service driver is registered with
	417	* pcie_port_service_register(), this function will be called by the driver core
	418	* whenever match is found between the driver and a port service device.
	419	*/
fa6c9937	420	static int pcie_port_probe_service(struct device *dev)
1da177e4	421	{
fa6c9937 RW	422	struct pcie_device *pciedev;
	423	struct pcie_port_service_driver *driver;
	424	int status;
	425
	426	if (!dev \|\| !dev->driver)
	427	return -ENODEV;
	428
	429	driver = to_service_driver(dev->driver);
	430	if (!driver \|\| !driver->probe)
	431	return -ENODEV;
	432
	433	pciedev = to_pcie_device(dev);
0516c8bc	434	status = driver->probe(pciedev);
fa6c9937 RW	435	if (!status) {
	436	dev_printk(KERN_DEBUG, dev, "service driver %s loaded\n",
	437	driver->name);
	438	get_device(dev);
	439	}
	440	return status;
1da177e4 LT	441	}
1da177e4 LT	442
d9347371 RW	443	/**
	444	* pcie_port_remove_service - detach driver from given PCI Express port service
	445	* @dev: PCI Express port service device to handle
	446	*
	447	* If PCI Express port service driver is registered with
	448	* pcie_port_service_register(), this function will be called by the driver core
	449	* when device_unregister() is called for the port service device associated
	450	* with the driver.
	451	*/
fa6c9937	452	static int pcie_port_remove_service(struct device *dev)
1da177e4	453	{
fa6c9937 RW	454	struct pcie_device *pciedev;
	455	struct pcie_port_service_driver *driver;
	456
	457	if (!dev \|\| !dev->driver)
	458	return 0;
	459
	460	pciedev = to_pcie_device(dev);
	461	driver = to_service_driver(dev->driver);
	462	if (driver && driver->remove) {
	463	dev_printk(KERN_DEBUG, dev, "unloading service driver %s\n",
	464	driver->name);
	465	driver->remove(pciedev);
	466	put_device(dev);
	467	}
	468	return 0;
1da177e4 LT	469	}
1da177e4 LT	470
d9347371 RW	471	/**
	472	* pcie_port_shutdown_service - shut down given PCI Express port service
	473	* @dev: PCI Express port service device to handle
	474	*
	475	* If PCI Express port service driver is registered with
	476	* pcie_port_service_register(), this function will be called by the driver core
	477	* when device_shutdown() is called for the port service device associated
	478	* with the driver.
	479	*/
fa6c9937 RW	480	static void pcie_port_shutdown_service(struct device *dev) {}
fa6c9937 RW	481
d9347371 RW	482	/**
	483	* pcie_port_service_register - register PCI Express port service driver
	484	* @new: PCI Express port service driver to register
	485	*/
1da177e4 LT	486	int pcie_port_service_register(struct pcie_port_service_driver *new)
	487	{
	488	new->driver.name = (char *)new->name;
	489	new->driver.bus = &pcie_port_bus_type;
	490	new->driver.probe = pcie_port_probe_service;
	491	new->driver.remove = pcie_port_remove_service;
	492	new->driver.shutdown = pcie_port_shutdown_service;
1da177e4 LT	493
1da177e4 LT	494	return driver_register(&new->driver);
d0e2b4a0	495	}
40da4186	496	EXPORT_SYMBOL(pcie_port_service_register);
1da177e4	497
d9347371 RW	498	/**
	499	* pcie_port_service_unregister - unregister PCI Express port service driver
	500	* @drv: PCI Express port service driver to unregister
	501	*/
fa6c9937	502	void pcie_port_service_unregister(struct pcie_port_service_driver *drv)
1da177e4	503	{
fa6c9937	504	driver_unregister(&drv->driver);
1da177e4	505	}
1da177e4	506	EXPORT_SYMBOL(pcie_port_service_unregister);