[net-next-2.6.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 + PCIE_CAPABILITIES_REG, &reg16);
		entry = (reg16 >> 9) & PCIE_PORT_MSI_VECTOR_MASK;
		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 + PCIE_CAPABILITIES_REG, &reg16);
	/* Hot-Plug Capable */
	if (reg16 & PORT_TO_SLOT_MASK) {
		pci_read_config_dword(dev, 
			pos + PCIE_SLOT_CAPABILITIES_REG, &reg32);
		if (reg32 & SLOT_HP_CAPABLE_MASK)
			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)
{
	struct pcie_port_data *port_data;
	int status, capabilities, i, nr_serv;
	int irqs[PCIE_PORT_DEVICE_MAXSERVICES];

	capabilities = get_port_device_capability(dev);
	if (!capabilities)
		return -ENODEV;

	port_data = kzalloc(sizeof(*port_data), GFP_KERNEL);
	if (!port_data)
		return -ENOMEM;
	port_data->port_type = dev->pcie_type;
	pci_set_drvdata(dev, port_data);

	/* Enable PCI Express port device */
	status = pci_enable_device(dev);
	if (status)
		goto error_kfree;
	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 */
	for (i = 0, nr_serv = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++) {
		int service = 1 << i;

		if (!(capabilities & service))
			continue;

		status = pcie_device_init(dev, service, irqs[i]);
		if (!status)
			nr_serv++;
	}
	if (!nr_serv) {
		status = -ENODEV;
		goto error_cleanup_irqs;
	}
	return 0;

error_cleanup_irqs:
	cleanup_service_irqs(dev);
error_disable:
	pci_disable_device(dev);
error_kfree:
	kfree(port_data);
	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)
{
	struct pcie_port_data *port_data = pci_get_drvdata(dev);

	device_for_each_child(&dev->dev, NULL, remove_iter);
	cleanup_service_irqs(dev);
	pci_disable_device(dev);
	kfree(port_data);
}

/**
 * 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);
}

/**
 * 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_register);
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	{
1da177e4 LT	30	kfree(to_pcie_device(dev));
	31	}
	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);
b43d4513 RW	112	pci_read_config_word(dev, pos + PCIE_CAPABILITIES_REG, &reg16);
	113	entry = (reg16 >> 9) & PCIE_PORT_MSI_VECTOR_MASK;
	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);
1da177e4 LT	233	pci_read_config_word(dev, pos + PCIE_CAPABILITIES_REG, &reg16);
	234	/* Hot-Plug Capable */
	235	if (reg16 & PORT_TO_SLOT_MASK) {
	236	pci_read_config_dword(dev,
	237	pos + PCIE_SLOT_CAPABILITIES_REG, &reg32);
	238	if (reg32 & SLOT_HP_CAPABLE_MASK)
	239	services \|= PCIE_PORT_SERVICE_HP;
1bf83e55 RW	240	}
1bf83e55 RW	241	/* AER capable */
0927678f JB	242	if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR))
0927678f JB	243	services \|= PCIE_PORT_SERVICE_AER;
1bf83e55	244	/* VC support */
0927678f JB	245	if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_VC))
0927678f JB	246	services \|= PCIE_PORT_SERVICE_VC;
9e5d0b16 KK	247	/* Root ports are capable of generating PME too */
	248	if (dev->pcie_type == PCI_EXP_TYPE_ROOT_PORT)
	249	services \|= PCIE_PORT_SERVICE_PME;
1da177e4 LT	250
	251	return services;
	252	}
	253
facf6d16	254	/**
52a0f24b KK	255	* pcie_device_init - allocate and initialize PCI Express port service device
	256	* @pdev: PCI Express port to associate the service device with
	257	* @service: Type of service to associate with the service device
facf6d16	258	* @irq: Interrupt vector to associate with the service device
facf6d16	259	*/
52a0f24b	260	static int pcie_device_init(struct pci_dev *pdev, int service, int irq)
1da177e4	261	{
52a0f24b KK	262	int retval;
52a0f24b KK	263	struct pcie_device *pcie;
1da177e4 LT	264	struct device *device;
1da177e4 LT	265
52a0f24b KK	266	pcie = kzalloc(sizeof(*pcie), GFP_KERNEL);
	267	if (!pcie)
	268	return -ENOMEM;
	269	pcie->port = pdev;
	270	pcie->irq = irq;
	271	pcie->service = service;
1da177e4 LT	272
1da177e4 LT	273	/* Initialize generic device interface */
52a0f24b	274	device = &pcie->device;
1da177e4	275	device->bus = &pcie_port_bus_type;
1da177e4	276	device->release = release_pcie_device; /* callback to free pcie dev */
1a927133	277	dev_set_name(device, "%s:pcie%02x",
52a0f24b KK	278	pci_name(pdev),
	279	get_descriptor_id(pdev->pcie_type, service));
	280	device->parent = &pdev->dev;
	281
	282	retval = device_register(device);
	283	if (retval)
	284	kfree(pcie);
	285	else
	286	get_device(device);
	287	return retval;
1da177e4 LT	288	}
1da177e4 LT	289
facf6d16 RW	290	/**
	291	* pcie_port_device_register - register PCI Express port
	292	* @dev: PCI Express port to register
	293	*
	294	* Allocate the port extension structure and register services associated with
	295	* the port.
	296	*/
1da177e4 LT	297	int pcie_port_device_register(struct pci_dev *dev)
1da177e4 LT	298	{
1bf83e55	299	struct pcie_port_data *port_data;
dc535178 KK	300	int status, capabilities, i, nr_serv;
dc535178 KK	301	int irqs[PCIE_PORT_DEVICE_MAXSERVICES];
1da177e4	302
d013598d KK	303	capabilities = get_port_device_capability(dev);
	304	if (!capabilities)
	305	return -ENODEV;
	306
1bf83e55 RW	307	port_data = kzalloc(sizeof(*port_data), GFP_KERNEL);
1bf83e55 RW	308	if (!port_data)
5823d100	309	return -ENOMEM;
2dd60e96	310	port_data->port_type = dev->pcie_type;
dc535178	311	pci_set_drvdata(dev, port_data);
1da177e4	312
1ce5e830 KK	313	/* Enable PCI Express port device */
	314	status = pci_enable_device(dev);
	315	if (status)
	316	goto error_kfree;
	317	pci_set_master(dev);
	318
dc535178 KK	319	/*
	320	* Initialize service irqs. Don't use service devices that
	321	* require interrupts if there is no way to generate them.
	322	*/
	323	status = init_service_irqs(dev, irqs, capabilities);
	324	if (status) {
	325	capabilities &= PCIE_PORT_SERVICE_VC;
	326	if (!capabilities)
1ce5e830	327	goto error_disable;
f118c0c3	328	}
1da177e4 LT	329
1da177e4 LT	330	/* Allocate child services if any */
f118c0c3	331	for (i = 0, nr_serv = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++) {
90e9cd50	332	int service = 1 << i;
1da177e4	333
90e9cd50 RW	334	if (!(capabilities & service))
	335	continue;
	336
dc535178	337	status = pcie_device_init(dev, service, irqs[i]);
52a0f24b KK	338	if (!status)
52a0f24b KK	339	nr_serv++;
f118c0c3 RW	340	}
f118c0c3 RW	341	if (!nr_serv) {
f118c0c3	342	status = -ENODEV;
fbb5de70	343	goto error_cleanup_irqs;
1da177e4 LT	344	}
1da177e4 LT	345	return 0;
f118c0c3	346
fbb5de70 KK	347	error_cleanup_irqs:
fbb5de70 KK	348	cleanup_service_irqs(dev);
1ce5e830 KK	349	error_disable:
	350	pci_disable_device(dev);
	351	error_kfree:
f118c0c3 RW	352	kfree(port_data);
f118c0c3 RW	353	return status;
1da177e4 LT	354	}
	355
	356	#ifdef CONFIG_PM
d0e2b4a0	357	static int suspend_iter(struct device dev, void data)
1da177e4	358	{
1da177e4	359	struct pcie_port_service_driver *service_driver;
d0e2b4a0	360
	361	if ((dev->bus == &pcie_port_bus_type) &&
	362	(dev->driver)) {
	363	service_driver = to_service_driver(dev->driver);
	364	if (service_driver->suspend)
3a3c244c	365	service_driver->suspend(to_pcie_device(dev));
d0e2b4a0	366	}
	367	return 0;
	368	}
1da177e4	369
facf6d16 RW	370	/**
	371	* pcie_port_device_suspend - suspend port services associated with a PCIe port
	372	* @dev: PCI Express port to handle
facf6d16	373	*/
3a3c244c	374	int pcie_port_device_suspend(struct device *dev)
d0e2b4a0	375	{
3a3c244c	376	return device_for_each_child(dev, NULL, suspend_iter);
1da177e4 LT	377	}
1da177e4 LT	378
d0e2b4a0	379	static int resume_iter(struct device dev, void data)
d0e2b4a0	380	{
1da177e4 LT	381	struct pcie_port_service_driver *service_driver;
1da177e4 LT	382
d0e2b4a0	383	if ((dev->bus == &pcie_port_bus_type) &&
	384	(dev->driver)) {
	385	service_driver = to_service_driver(dev->driver);
	386	if (service_driver->resume)
	387	service_driver->resume(to_pcie_device(dev));
1da177e4	388	}
d0e2b4a0	389	return 0;
d0e2b4a0	390	}
1da177e4	391
facf6d16 RW	392	/**
	393	* pcie_port_device_suspend - resume port services associated with a PCIe port
	394	* @dev: PCI Express port to handle
	395	*/
3a3c244c	396	int pcie_port_device_resume(struct device *dev)
d0e2b4a0	397	{
3a3c244c	398	return device_for_each_child(dev, NULL, resume_iter);
1da177e4	399	}
3a3c244c	400	#endif /* PM */
1da177e4	401
d0e2b4a0	402	static int remove_iter(struct device dev, void data)
1da177e4	403	{
d0e2b4a0	404	if (dev->bus == &pcie_port_bus_type) {
ae40582e EB	405	put_device(dev);
ae40582e EB	406	device_unregister(dev);
1da177e4	407	}
d0e2b4a0	408	return 0;
	409	}
	410
facf6d16 RW	411	/**
	412	* pcie_port_device_remove - unregister PCI Express port service devices
	413	* @dev: PCI Express port the service devices to unregister are associated with
	414	*
	415	* Remove PCI Express port service devices associated with given port and
	416	* disable MSI-X or MSI for the port.
	417	*/
d0e2b4a0	418	void pcie_port_device_remove(struct pci_dev *dev)
d0e2b4a0	419	{
1bf83e55	420	struct pcie_port_data *port_data = pci_get_drvdata(dev);
d0e2b4a0	421
ae40582e	422	device_for_each_child(&dev->dev, NULL, remove_iter);
fbb5de70	423	cleanup_service_irqs(dev);
dc535178	424	pci_disable_device(dev);
1bf83e55	425	kfree(port_data);
1da177e4 LT	426	}
1da177e4 LT	427
d9347371 RW	428	/**
	429	* pcie_port_probe_service - probe driver for given PCI Express port service
	430	* @dev: PCI Express port service device to probe against
	431	*
	432	* If PCI Express port service driver is registered with
	433	* pcie_port_service_register(), this function will be called by the driver core
	434	* whenever match is found between the driver and a port service device.
	435	*/
fa6c9937	436	static int pcie_port_probe_service(struct device *dev)
1da177e4	437	{
fa6c9937 RW	438	struct pcie_device *pciedev;
	439	struct pcie_port_service_driver *driver;
	440	int status;
	441
	442	if (!dev \|\| !dev->driver)
	443	return -ENODEV;
	444
	445	driver = to_service_driver(dev->driver);
	446	if (!driver \|\| !driver->probe)
	447	return -ENODEV;
	448
	449	pciedev = to_pcie_device(dev);
0516c8bc	450	status = driver->probe(pciedev);
fa6c9937 RW	451	if (!status) {
	452	dev_printk(KERN_DEBUG, dev, "service driver %s loaded\n",
	453	driver->name);
	454	get_device(dev);
	455	}
	456	return status;
1da177e4 LT	457	}
1da177e4 LT	458
d9347371 RW	459	/**
	460	* pcie_port_remove_service - detach driver from given PCI Express port service
	461	* @dev: PCI Express port service device to handle
	462	*
	463	* If PCI Express port service driver is registered with
	464	* pcie_port_service_register(), this function will be called by the driver core
	465	* when device_unregister() is called for the port service device associated
	466	* with the driver.
	467	*/
fa6c9937	468	static int pcie_port_remove_service(struct device *dev)
1da177e4	469	{
fa6c9937 RW	470	struct pcie_device *pciedev;
	471	struct pcie_port_service_driver *driver;
	472
	473	if (!dev \|\| !dev->driver)
	474	return 0;
	475
	476	pciedev = to_pcie_device(dev);
	477	driver = to_service_driver(dev->driver);
	478	if (driver && driver->remove) {
	479	dev_printk(KERN_DEBUG, dev, "unloading service driver %s\n",
	480	driver->name);
	481	driver->remove(pciedev);
	482	put_device(dev);
	483	}
	484	return 0;
1da177e4 LT	485	}
1da177e4 LT	486
d9347371 RW	487	/**
	488	* pcie_port_shutdown_service - shut down given PCI Express port service
	489	* @dev: PCI Express port service device to handle
	490	*
	491	* If PCI Express port service driver is registered with
	492	* pcie_port_service_register(), this function will be called by the driver core
	493	* when device_shutdown() is called for the port service device associated
	494	* with the driver.
	495	*/
fa6c9937 RW	496	static void pcie_port_shutdown_service(struct device *dev) {}
fa6c9937 RW	497
d9347371 RW	498	/**
	499	* pcie_port_service_register - register PCI Express port service driver
	500	* @new: PCI Express port service driver to register
	501	*/
1da177e4 LT	502	int pcie_port_service_register(struct pcie_port_service_driver *new)
	503	{
	504	new->driver.name = (char *)new->name;
	505	new->driver.bus = &pcie_port_bus_type;
	506	new->driver.probe = pcie_port_probe_service;
	507	new->driver.remove = pcie_port_remove_service;
	508	new->driver.shutdown = pcie_port_shutdown_service;
1da177e4 LT	509
1da177e4 LT	510	return driver_register(&new->driver);
d0e2b4a0	511	}
1da177e4	512
d9347371 RW	513	/**
	514	* pcie_port_service_unregister - unregister PCI Express port service driver
	515	* @drv: PCI Express port service driver to unregister
	516	*/
fa6c9937	517	void pcie_port_service_unregister(struct pcie_port_service_driver *drv)
1da177e4	518	{
fa6c9937	519	driver_unregister(&drv->driver);
1da177e4 LT	520	}
	521
	522	EXPORT_SYMBOL(pcie_port_service_register);
	523	EXPORT_SYMBOL(pcie_port_service_unregister);