[mirror_ubuntu-hirsute-kernel.git] / drivers / pci / pci-driver.c

/*
 * drivers/pci/pci-driver.c
 *
 */

#include <linux/pci.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/mempolicy.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include "pci.h"

/*
 *  Registration of PCI drivers and handling of hot-pluggable devices.
 */

/*
 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
 */

struct pci_dynid {
	struct list_head node;
	struct pci_device_id id;
};

#ifdef CONFIG_HOTPLUG

/**
 * store_new_id - add a new PCI device ID to this driver and re-probe devices
 * @driver: target device driver
 * @buf: buffer for scanning device ID data
 * @count: input size
 *
 * Adds a new dynamic pci device ID to this driver,
 * and causes the driver to probe for all devices again.
 */
static ssize_t
store_new_id(struct device_driver *driver, const char *buf, size_t count)
{
	struct pci_dynid *dynid;
	struct pci_driver *pdrv = to_pci_driver(driver);
	__u32 vendor=PCI_ANY_ID, device=PCI_ANY_ID, subvendor=PCI_ANY_ID,
		subdevice=PCI_ANY_ID, class=0, class_mask=0;
	unsigned long driver_data=0;
	int fields=0;

	fields = sscanf(buf, "%x %x %x %x %x %x %lux",
			&vendor, &device, &subvendor, &subdevice,
			&class, &class_mask, &driver_data);
	if (fields < 0)
		return -EINVAL;

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

	INIT_LIST_HEAD(&dynid->node);
	dynid->id.vendor = vendor;
	dynid->id.device = device;
	dynid->id.subvendor = subvendor;
	dynid->id.subdevice = subdevice;
	dynid->id.class = class;
	dynid->id.class_mask = class_mask;
	dynid->id.driver_data = pdrv->dynids.use_driver_data ?
		driver_data : 0UL;

	spin_lock(&pdrv->dynids.lock);
	list_add_tail(&pdrv->dynids.list, &dynid->node);
	spin_unlock(&pdrv->dynids.lock);

	if (get_driver(&pdrv->driver)) {
		driver_attach(&pdrv->driver);
		put_driver(&pdrv->driver);
	}

	return count;
}
static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);

static void
pci_free_dynids(struct pci_driver *drv)
{
	struct pci_dynid *dynid, *n;

	spin_lock(&drv->dynids.lock);
	list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
		list_del(&dynid->node);
		kfree(dynid);
	}
	spin_unlock(&drv->dynids.lock);
}

static int
pci_create_newid_file(struct pci_driver *drv)
{
	int error = 0;
	if (drv->probe != NULL)
		error = sysfs_create_file(&drv->driver.kobj,
					  &driver_attr_new_id.attr);
	return error;
}

#else /* !CONFIG_HOTPLUG */
static inline void pci_free_dynids(struct pci_driver *drv) {}
static inline int pci_create_newid_file(struct pci_driver *drv)
{
	return 0;
}
#endif

/**
 * pci_match_id - See if a pci device matches a given pci_id table
 * @ids: array of PCI device id structures to search in
 * @dev: the PCI device structure to match against.
 *
 * Used by a driver to check whether a PCI device present in the
 * system is in its list of supported devices.  Returns the matching
 * pci_device_id structure or %NULL if there is no match.
 *
 * Depreciated, don't use this as it will not catch any dynamic ids
 * that a driver might want to check for.
 */
const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
					 struct pci_dev *dev)
{
	if (ids) {
		while (ids->vendor || ids->subvendor || ids->class_mask) {
			if (pci_match_one_device(ids, dev))
				return ids;
			ids++;
		}
	}
	return NULL;
}

/**
 * pci_match_device - Tell if a PCI device structure has a matching
 *                    PCI device id structure
 * @ids: array of PCI device id structures to search in
 * @dev: the PCI device structure to match against
 * @drv: the PCI driver to match against
 *
 * Used by a driver to check whether a PCI device present in the
 * system is in its list of supported devices.  Returns the matching
 * pci_device_id structure or %NULL if there is no match.
 */
const struct pci_device_id *pci_match_device(struct pci_driver *drv,
					     struct pci_dev *dev)
{
	const struct pci_device_id *id;
	struct pci_dynid *dynid;

	id = pci_match_id(drv->id_table, dev);
	if (id)
		return id;

	/* static ids didn't match, lets look at the dynamic ones */
	spin_lock(&drv->dynids.lock);
	list_for_each_entry(dynid, &drv->dynids.list, node) {
		if (pci_match_one_device(&dynid->id, dev)) {
			spin_unlock(&drv->dynids.lock);
			return &dynid->id;
		}
	}
	spin_unlock(&drv->dynids.lock);
	return NULL;
}

static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
			  const struct pci_device_id *id)
{
	int error;
#ifdef CONFIG_NUMA
	/* Execute driver initialization on node where the
	   device's bus is attached to.  This way the driver likely
	   allocates its local memory on the right node without
	   any need to change it. */
	struct mempolicy *oldpol;
	cpumask_t oldmask = current->cpus_allowed;
	int node = pcibus_to_node(dev->bus);
	if (node >= 0 && node_online(node))
	    set_cpus_allowed(current, node_to_cpumask(node));
	/* And set default memory allocation policy */
	oldpol = current->mempolicy;
	current->mempolicy = &default_policy;
	mpol_get(current->mempolicy);
#endif
	error = drv->probe(dev, id);
#ifdef CONFIG_NUMA
	set_cpus_allowed(current, oldmask);
	mpol_free(current->mempolicy);
	current->mempolicy = oldpol;
#endif
	return error;
}

/**
 * __pci_device_probe()
 * @drv: driver to call to check if it wants the PCI device
 * @pci_dev: PCI device being probed
 * 
 * returns 0 on success, else error.
 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
 */
static int
__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
{
	const struct pci_device_id *id;
	int error = 0;

	if (!pci_dev->driver && drv->probe) {
		error = -ENODEV;

		id = pci_match_device(drv, pci_dev);
		if (id)
			error = pci_call_probe(drv, pci_dev, id);
		if (error >= 0) {
			pci_dev->driver = drv;
			error = 0;
		}
	}
	return error;
}

static int pci_device_probe(struct device * dev)
{
	int error = 0;
	struct pci_driver *drv;
	struct pci_dev *pci_dev;

	drv = to_pci_driver(dev->driver);
	pci_dev = to_pci_dev(dev);
	pci_dev_get(pci_dev);
	error = __pci_device_probe(drv, pci_dev);
	if (error)
		pci_dev_put(pci_dev);

	return error;
}

static int pci_device_remove(struct device * dev)
{
	struct pci_dev * pci_dev = to_pci_dev(dev);
	struct pci_driver * drv = pci_dev->driver;

	if (drv) {
		if (drv->remove)
			drv->remove(pci_dev);
		pci_dev->driver = NULL;
	}

	/*
	 * We would love to complain here if pci_dev->is_enabled is set, that
	 * the driver should have called pci_disable_device(), but the
	 * unfortunate fact is there are too many odd BIOS and bridge setups
	 * that don't like drivers doing that all of the time.  
	 * Oh well, we can dream of sane hardware when we sleep, no matter how
	 * horrible the crap we have to deal with is when we are awake...
	 */

	pci_dev_put(pci_dev);
	return 0;
}

static int pci_device_suspend(struct device * dev, pm_message_t state)
{
	struct pci_dev * pci_dev = to_pci_dev(dev);
	struct pci_driver * drv = pci_dev->driver;
	int i = 0;

	if (drv && drv->suspend)
		i = drv->suspend(pci_dev, state);
	else
		pci_save_state(pci_dev);
	return i;
}


/*
 * Default resume method for devices that have no driver provided resume,
 * or not even a driver at all.
 */
static void pci_default_resume(struct pci_dev *pci_dev)
{
	int retval;

	/* restore the PCI config space */
	pci_restore_state(pci_dev);
	/* if the device was enabled before suspend, reenable */
	if (pci_dev->is_enabled)
		retval = pci_enable_device(pci_dev);
	/* if the device was busmaster before the suspend, make it busmaster again */
	if (pci_dev->is_busmaster)
		pci_set_master(pci_dev);
}

static int pci_device_resume(struct device * dev)
{
	struct pci_dev * pci_dev = to_pci_dev(dev);
	struct pci_driver * drv = pci_dev->driver;

	if (drv && drv->resume)
		drv->resume(pci_dev);
	else
		pci_default_resume(pci_dev);
	return 0;
}

static void pci_device_shutdown(struct device *dev)
{
	struct pci_dev *pci_dev = to_pci_dev(dev);
	struct pci_driver *drv = pci_dev->driver;

	if (drv && drv->shutdown)
		drv->shutdown(pci_dev);
}

#define kobj_to_pci_driver(obj) container_of(obj, struct device_driver, kobj)
#define attr_to_driver_attribute(obj) container_of(obj, struct driver_attribute, attr)

static ssize_t
pci_driver_attr_show(struct kobject * kobj, struct attribute *attr, char *buf)
{
	struct device_driver *driver = kobj_to_pci_driver(kobj);
	struct driver_attribute *dattr = attr_to_driver_attribute(attr);
	ssize_t ret;

	if (!get_driver(driver))
		return -ENODEV;

	ret = dattr->show ? dattr->show(driver, buf) : -EIO;

	put_driver(driver);
	return ret;
}

static ssize_t
pci_driver_attr_store(struct kobject * kobj, struct attribute *attr,
		      const char *buf, size_t count)
{
	struct device_driver *driver = kobj_to_pci_driver(kobj);
	struct driver_attribute *dattr = attr_to_driver_attribute(attr);
	ssize_t ret;

	if (!get_driver(driver))
		return -ENODEV;

	ret = dattr->store ? dattr->store(driver, buf, count) : -EIO;

	put_driver(driver);
	return ret;
}

static struct sysfs_ops pci_driver_sysfs_ops = {
	.show = pci_driver_attr_show,
	.store = pci_driver_attr_store,
};
static struct kobj_type pci_driver_kobj_type = {
	.sysfs_ops = &pci_driver_sysfs_ops,
};

/**
 * __pci_register_driver - register a new pci driver
 * @drv: the driver structure to register
 * @owner: owner module of drv
 * 
 * Adds the driver structure to the list of registered drivers.
 * Returns a negative value on error, otherwise 0. 
 * If no error occurred, the driver remains registered even if 
 * no device was claimed during registration.
 */
int __pci_register_driver(struct pci_driver *drv, struct module *owner)
{
	int error;

	/* initialize common driver fields */
	drv->driver.name = drv->name;
	drv->driver.bus = &pci_bus_type;
	drv->driver.owner = owner;
	drv->driver.kobj.ktype = &pci_driver_kobj_type;

	spin_lock_init(&drv->dynids.lock);
	INIT_LIST_HEAD(&drv->dynids.list);

	/* register with core */
	error = driver_register(&drv->driver);

	if (!error)
		error = pci_create_newid_file(drv);

	return error;
}

/**
 * pci_unregister_driver - unregister a pci driver
 * @drv: the driver structure to unregister
 * 
 * Deletes the driver structure from the list of registered PCI drivers,
 * gives it a chance to clean up by calling its remove() function for
 * each device it was responsible for, and marks those devices as
 * driverless.
 */

void
pci_unregister_driver(struct pci_driver *drv)
{
	driver_unregister(&drv->driver);
	pci_free_dynids(drv);
}

static struct pci_driver pci_compat_driver = {
	.name = "compat"
};

/**
 * pci_dev_driver - get the pci_driver of a device
 * @dev: the device to query
 *
 * Returns the appropriate pci_driver structure or %NULL if there is no 
 * registered driver for the device.
 */
struct pci_driver *
pci_dev_driver(const struct pci_dev *dev)
{
	if (dev->driver)
		return dev->driver;
	else {
		int i;
		for(i=0; i<=PCI_ROM_RESOURCE; i++)
			if (dev->resource[i].flags & IORESOURCE_BUSY)
				return &pci_compat_driver;
	}
	return NULL;
}

/**
 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
 * @dev: the PCI device structure to match against
 * @drv: the device driver to search for matching PCI device id structures
 * 
 * Used by a driver to check whether a PCI device present in the
 * system is in its list of supported devices. Returns the matching
 * pci_device_id structure or %NULL if there is no match.
 */
static int pci_bus_match(struct device *dev, struct device_driver *drv)
{
	struct pci_dev *pci_dev = to_pci_dev(dev);
	struct pci_driver *pci_drv = to_pci_driver(drv);
	const struct pci_device_id *found_id;

	found_id = pci_match_device(pci_drv, pci_dev);
	if (found_id)
		return 1;

	return 0;
}

/**
 * pci_dev_get - increments the reference count of the pci device structure
 * @dev: the device being referenced
 *
 * Each live reference to a device should be refcounted.
 *
 * Drivers for PCI devices should normally record such references in
 * their probe() methods, when they bind to a device, and release
 * them by calling pci_dev_put(), in their disconnect() methods.
 *
 * A pointer to the device with the incremented reference counter is returned.
 */
struct pci_dev *pci_dev_get(struct pci_dev *dev)
{
	if (dev)
		get_device(&dev->dev);
	return dev;
}

/**
 * pci_dev_put - release a use of the pci device structure
 * @dev: device that's been disconnected
 *
 * Must be called when a user of a device is finished with it.  When the last
 * user of the device calls this function, the memory of the device is freed.
 */
void pci_dev_put(struct pci_dev *dev)
{
	if (dev)
		put_device(&dev->dev);
}

#ifndef CONFIG_HOTPLUG
int pci_uevent(struct device *dev, char **envp, int num_envp,
	       char *buffer, int buffer_size)
{
	return -ENODEV;
}
#endif

struct bus_type pci_bus_type = {
	.name		= "pci",
	.match		= pci_bus_match,
	.uevent		= pci_uevent,
	.probe		= pci_device_probe,
	.remove		= pci_device_remove,
	.suspend	= pci_device_suspend,
	.shutdown	= pci_device_shutdown,
	.resume		= pci_device_resume,
	.dev_attrs	= pci_dev_attrs,
};

static int __init pci_driver_init(void)
{
	return bus_register(&pci_bus_type);
}

postcore_initcall(pci_driver_init);

EXPORT_SYMBOL(pci_match_id);
EXPORT_SYMBOL(pci_match_device);
EXPORT_SYMBOL(__pci_register_driver);
EXPORT_SYMBOL(pci_unregister_driver);
EXPORT_SYMBOL(pci_dev_driver);
EXPORT_SYMBOL(pci_bus_type);
EXPORT_SYMBOL(pci_dev_get);
EXPORT_SYMBOL(pci_dev_put);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* drivers/pci/pci-driver.c
	3	*
	4	*/
	5
	6	#include <linux/pci.h>
	7	#include <linux/module.h>
	8	#include <linux/init.h>
	9	#include <linux/device.h>
d42c6997	10	#include <linux/mempolicy.h>
4e57b681 TS	11	#include <linux/string.h>
4e57b681 TS	12	#include <linux/slab.h>
8c65b4a6	13	#include <linux/sched.h>
1da177e4 LT	14	#include "pci.h"
	15
	16	/*
	17	* Registration of PCI drivers and handling of hot-pluggable devices.
	18	*/
	19
	20	/*
	21	* Dynamic device IDs are disabled for !CONFIG_HOTPLUG
	22	*/
	23
75865858 GKH	24	struct pci_dynid {
	25	struct list_head node;
	26	struct pci_device_id id;
	27	};
1da177e4	28
3d3c2ae1 GKH	29	#ifdef CONFIG_HOTPLUG
3d3c2ae1 GKH	30
1da177e4	31	/**
8f7020d3 RD	32	* store_new_id - add a new PCI device ID to this driver and re-probe devices
	33	* @driver: target device driver
	34	* @buf: buffer for scanning device ID data
	35	* @count: input size
1da177e4 LT	36	*
	37	* Adds a new dynamic pci device ID to this driver,
	38	* and causes the driver to probe for all devices again.
	39	*/
f8eb1005	40	static ssize_t
1da177e4 LT	41	store_new_id(struct device_driver driver, const char buf, size_t count)
1da177e4 LT	42	{
75865858	43	struct pci_dynid *dynid;
1da177e4 LT	44	struct pci_driver *pdrv = to_pci_driver(driver);
	45	__u32 vendor=PCI_ANY_ID, device=PCI_ANY_ID, subvendor=PCI_ANY_ID,
	46	subdevice=PCI_ANY_ID, class=0, class_mask=0;
	47	unsigned long driver_data=0;
	48	int fields=0;
	49
	50	fields = sscanf(buf, "%x %x %x %x %x %x %lux",
	51	&vendor, &device, &subvendor, &subdevice,
	52	&class, &class_mask, &driver_data);
	53	if (fields < 0)
	54	return -EINVAL;
	55
f5afe806	56	dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
1da177e4 LT	57	if (!dynid)
	58	return -ENOMEM;
	59
1da177e4 LT	60	INIT_LIST_HEAD(&dynid->node);
	61	dynid->id.vendor = vendor;
	62	dynid->id.device = device;
	63	dynid->id.subvendor = subvendor;
	64	dynid->id.subdevice = subdevice;
	65	dynid->id.class = class;
	66	dynid->id.class_mask = class_mask;
	67	dynid->id.driver_data = pdrv->dynids.use_driver_data ?
	68	driver_data : 0UL;
	69
	70	spin_lock(&pdrv->dynids.lock);
	71	list_add_tail(&pdrv->dynids.list, &dynid->node);
	72	spin_unlock(&pdrv->dynids.lock);
	73
75865858 GKH	74	if (get_driver(&pdrv->driver)) {
	75	driver_attach(&pdrv->driver);
	76	put_driver(&pdrv->driver);
1da177e4 LT	77	}
	78
	79	return count;
	80	}
1da177e4	81	static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
1da177e4 LT	82
	83	static void
	84	pci_free_dynids(struct pci_driver *drv)
	85	{
75865858	86	struct pci_dynid dynid, n;
1da177e4 LT	87
1da177e4 LT	88	spin_lock(&drv->dynids.lock);
75865858	89	list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
1da177e4 LT	90	list_del(&dynid->node);
	91	kfree(dynid);
	92	}
	93	spin_unlock(&drv->dynids.lock);
	94	}
	95
	96	static int
	97	pci_create_newid_file(struct pci_driver *drv)
	98	{
	99	int error = 0;
	100	if (drv->probe != NULL)
	101	error = sysfs_create_file(&drv->driver.kobj,
	102	&driver_attr_new_id.attr);
	103	return error;
	104	}
	105
1da177e4	106	#else /* !CONFIG_HOTPLUG */
1da177e4 LT	107	static inline void pci_free_dynids(struct pci_driver *drv) {}
	108	static inline int pci_create_newid_file(struct pci_driver *drv)
	109	{
	110	return 0;
	111	}
1da177e4 LT	112	#endif
	113
	114	/**
75865858	115	* pci_match_id - See if a pci device matches a given pci_id table
1da177e4	116	* @ids: array of PCI device id structures to search in
75865858 GKH	117	* @dev: the PCI device structure to match against.
75865858 GKH	118	*
1da177e4	119	* Used by a driver to check whether a PCI device present in the
75865858	120	* system is in its list of supported devices. Returns the matching
1da177e4	121	* pci_device_id structure or %NULL if there is no match.
75865858 GKH	122	*
	123	* Depreciated, don't use this as it will not catch any dynamic ids
	124	* that a driver might want to check for.
1da177e4	125	*/
75865858 GKH	126	const struct pci_device_id pci_match_id(const struct pci_device_id ids,
75865858 GKH	127	struct pci_dev *dev)
1da177e4	128	{
75865858 GKH	129	if (ids) {
	130	while (ids->vendor \|\| ids->subvendor \|\| ids->class_mask) {
	131	if (pci_match_one_device(ids, dev))
	132	return ids;
	133	ids++;
	134	}
1da177e4 LT	135	}
	136	return NULL;
	137	}
	138
	139	/**
75865858 GKH	140	* pci_match_device - Tell if a PCI device structure has a matching
	141	* PCI device id structure
	142	* @ids: array of PCI device id structures to search in
	143	* @dev: the PCI device structure to match against
	144	* @drv: the PCI driver to match against
	145	*
	146	* Used by a driver to check whether a PCI device present in the
	147	* system is in its list of supported devices. Returns the matching
	148	* pci_device_id structure or %NULL if there is no match.
1da177e4	149	*/
75865858 GKH	150	const struct pci_device_id pci_match_device(struct pci_driver drv,
	151	struct pci_dev *dev)
	152	{
1da177e4	153	const struct pci_device_id *id;
75865858	154	struct pci_dynid *dynid;
1da177e4	155
75865858	156	id = pci_match_id(drv->id_table, dev);
1da177e4	157	if (id)
75865858 GKH	158	return id;
	159
	160	/* static ids didn't match, lets look at the dynamic ones */
	161	spin_lock(&drv->dynids.lock);
	162	list_for_each_entry(dynid, &drv->dynids.list, node) {
	163	if (pci_match_one_device(&dynid->id, dev)) {
	164	spin_unlock(&drv->dynids.lock);
	165	return &dynid->id;
	166	}
1da177e4	167	}
75865858 GKH	168	spin_unlock(&drv->dynids.lock);
75865858 GKH	169	return NULL;
1da177e4 LT	170	}
1da177e4 LT	171
d42c6997 AK	172	static int pci_call_probe(struct pci_driver drv, struct pci_dev dev,
	173	const struct pci_device_id *id)
	174	{
	175	int error;
	176	#ifdef CONFIG_NUMA
	177	/* Execute driver initialization on node where the
	178	device's bus is attached to. This way the driver likely
	179	allocates its local memory on the right node without
	180	any need to change it. */
	181	struct mempolicy *oldpol;
	182	cpumask_t oldmask = current->cpus_allowed;
	183	int node = pcibus_to_node(dev->bus);
	184	if (node >= 0 && node_online(node))
	185	set_cpus_allowed(current, node_to_cpumask(node));
	186	/* And set default memory allocation policy */
	187	oldpol = current->mempolicy;
	188	current->mempolicy = &default_policy;
	189	mpol_get(current->mempolicy);
	190	#endif
	191	error = drv->probe(dev, id);
	192	#ifdef CONFIG_NUMA
	193	set_cpus_allowed(current, oldmask);
	194	mpol_free(current->mempolicy);
	195	current->mempolicy = oldpol;
	196	#endif
	197	return error;
	198	}
	199
1da177e4 LT	200	/**
1da177e4 LT	201	* __pci_device_probe()
8f7020d3 RD	202	* @drv: driver to call to check if it wants the PCI device
8f7020d3 RD	203	* @pci_dev: PCI device being probed
1da177e4	204	*
8f7020d3	205	* returns 0 on success, else error.
1da177e4 LT	206	* side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
	207	*/
	208	static int
	209	__pci_device_probe(struct pci_driver drv, struct pci_dev pci_dev)
75865858 GKH	210	{
75865858 GKH	211	const struct pci_device_id *id;
1da177e4 LT	212	int error = 0;
	213
	214	if (!pci_dev->driver && drv->probe) {
75865858 GKH	215	error = -ENODEV;
	216
	217	id = pci_match_device(drv, pci_dev);
	218	if (id)
d42c6997	219	error = pci_call_probe(drv, pci_dev, id);
75865858 GKH	220	if (error >= 0) {
	221	pci_dev->driver = drv;
	222	error = 0;
	223	}
1da177e4 LT	224	}
	225	return error;
	226	}
	227
	228	static int pci_device_probe(struct device * dev)
	229	{
	230	int error = 0;
	231	struct pci_driver *drv;
	232	struct pci_dev *pci_dev;
	233
	234	drv = to_pci_driver(dev->driver);
	235	pci_dev = to_pci_dev(dev);
	236	pci_dev_get(pci_dev);
	237	error = __pci_device_probe(drv, pci_dev);
	238	if (error)
	239	pci_dev_put(pci_dev);
	240
	241	return error;
	242	}
	243
	244	static int pci_device_remove(struct device * dev)
	245	{
	246	struct pci_dev * pci_dev = to_pci_dev(dev);
	247	struct pci_driver * drv = pci_dev->driver;
	248
	249	if (drv) {
	250	if (drv->remove)
	251	drv->remove(pci_dev);
	252	pci_dev->driver = NULL;
	253	}
	254
	255	/*
	256	* We would love to complain here if pci_dev->is_enabled is set, that
	257	* the driver should have called pci_disable_device(), but the
	258	* unfortunate fact is there are too many odd BIOS and bridge setups
	259	* that don't like drivers doing that all of the time.
	260	* Oh well, we can dream of sane hardware when we sleep, no matter how
	261	* horrible the crap we have to deal with is when we are awake...
	262	*/
	263
	264	pci_dev_put(pci_dev);
	265	return 0;
	266	}
	267
	268	static int pci_device_suspend(struct device * dev, pm_message_t state)
	269	{
	270	struct pci_dev * pci_dev = to_pci_dev(dev);
	271	struct pci_driver * drv = pci_dev->driver;
	272	int i = 0;
	273
	274	if (drv && drv->suspend)
	275	i = drv->suspend(pci_dev, state);
	276	else
	277	pci_save_state(pci_dev);
	278	return i;
	279	}
	280
	281
95a62965	282	/*
1da177e4 LT	283	* Default resume method for devices that have no driver provided resume,
	284	* or not even a driver at all.
	285	*/
	286	static void pci_default_resume(struct pci_dev *pci_dev)
	287	{
95a62965 GKH	288	int retval;
95a62965 GKH	289
1da177e4 LT	290	/* restore the PCI config space */
	291	pci_restore_state(pci_dev);
	292	/* if the device was enabled before suspend, reenable */
	293	if (pci_dev->is_enabled)
95a62965	294	retval = pci_enable_device(pci_dev);
1da177e4 LT	295	/* if the device was busmaster before the suspend, make it busmaster again */
	296	if (pci_dev->is_busmaster)
	297	pci_set_master(pci_dev);
	298	}
	299
	300	static int pci_device_resume(struct device * dev)
	301	{
	302	struct pci_dev * pci_dev = to_pci_dev(dev);
	303	struct pci_driver * drv = pci_dev->driver;
	304
	305	if (drv && drv->resume)
	306	drv->resume(pci_dev);
	307	else
	308	pci_default_resume(pci_dev);
	309	return 0;
	310	}
	311
c8958177 GKH	312	static void pci_device_shutdown(struct device *dev)
	313	{
	314	struct pci_dev *pci_dev = to_pci_dev(dev);
	315	struct pci_driver *drv = pci_dev->driver;
	316
	317	if (drv && drv->shutdown)
	318	drv->shutdown(pci_dev);
	319	}
1da177e4 LT	320
	321	#define kobj_to_pci_driver(obj) container_of(obj, struct device_driver, kobj)
	322	#define attr_to_driver_attribute(obj) container_of(obj, struct driver_attribute, attr)
	323
	324	static ssize_t
	325	pci_driver_attr_show(struct kobject * kobj, struct attribute attr, char buf)
	326	{
	327	struct device_driver *driver = kobj_to_pci_driver(kobj);
	328	struct driver_attribute *dattr = attr_to_driver_attribute(attr);
fc7e4828	329	ssize_t ret;
1da177e4	330
fc7e4828 DT	331	if (!get_driver(driver))
	332	return -ENODEV;
	333
	334	ret = dattr->show ? dattr->show(driver, buf) : -EIO;
	335
	336	put_driver(driver);
1da177e4 LT	337	return ret;
	338	}
	339
	340	static ssize_t
	341	pci_driver_attr_store(struct kobject * kobj, struct attribute *attr,
	342	const char *buf, size_t count)
	343	{
	344	struct device_driver *driver = kobj_to_pci_driver(kobj);
	345	struct driver_attribute *dattr = attr_to_driver_attribute(attr);
fc7e4828	346	ssize_t ret;
1da177e4	347
fc7e4828 DT	348	if (!get_driver(driver))
	349	return -ENODEV;
	350
	351	ret = dattr->store ? dattr->store(driver, buf, count) : -EIO;
	352
	353	put_driver(driver);
1da177e4 LT	354	return ret;
	355	}
	356
	357	static struct sysfs_ops pci_driver_sysfs_ops = {
	358	.show = pci_driver_attr_show,
	359	.store = pci_driver_attr_store,
	360	};
	361	static struct kobj_type pci_driver_kobj_type = {
	362	.sysfs_ops = &pci_driver_sysfs_ops,
	363	};
	364
1da177e4	365	/**
863b18f4	366	* __pci_register_driver - register a new pci driver
1da177e4	367	* @drv: the driver structure to register
863b18f4	368	* @owner: owner module of drv
1da177e4 LT	369	*
	370	* Adds the driver structure to the list of registered drivers.
	371	* Returns a negative value on error, otherwise 0.
eaae4b3a	372	* If no error occurred, the driver remains registered even if
1da177e4 LT	373	* no device was claimed during registration.
1da177e4 LT	374	*/
863b18f4	375	int __pci_register_driver(struct pci_driver drv, struct module owner)
1da177e4 LT	376	{
	377	int error;
	378
	379	/* initialize common driver fields */
	380	drv->driver.name = drv->name;
	381	drv->driver.bus = &pci_bus_type;
863b18f4	382	drv->driver.owner = owner;
1da177e4	383	drv->driver.kobj.ktype = &pci_driver_kobj_type;
75865858 GKH	384
	385	spin_lock_init(&drv->dynids.lock);
	386	INIT_LIST_HEAD(&drv->dynids.list);
1da177e4 LT	387
	388	/* register with core */
	389	error = driver_register(&drv->driver);
	390
	391	if (!error)
75865858	392	error = pci_create_newid_file(drv);
1da177e4 LT	393
	394	return error;
	395	}
	396
	397	/**
	398	* pci_unregister_driver - unregister a pci driver
	399	* @drv: the driver structure to unregister
	400	*
	401	* Deletes the driver structure from the list of registered PCI drivers,
	402	* gives it a chance to clean up by calling its remove() function for
	403	* each device it was responsible for, and marks those devices as
	404	* driverless.
	405	*/
	406
	407	void
	408	pci_unregister_driver(struct pci_driver *drv)
	409	{
	410	driver_unregister(&drv->driver);
	411	pci_free_dynids(drv);
	412	}
	413
	414	static struct pci_driver pci_compat_driver = {
	415	.name = "compat"
	416	};
	417
	418	/**
	419	* pci_dev_driver - get the pci_driver of a device
	420	* @dev: the device to query
	421	*
	422	* Returns the appropriate pci_driver structure or %NULL if there is no
	423	* registered driver for the device.
	424	*/
	425	struct pci_driver *
	426	pci_dev_driver(const struct pci_dev *dev)
	427	{
	428	if (dev->driver)
	429	return dev->driver;
	430	else {
	431	int i;
	432	for(i=0; i<=PCI_ROM_RESOURCE; i++)
	433	if (dev->resource[i].flags & IORESOURCE_BUSY)
	434	return &pci_compat_driver;
	435	}
	436	return NULL;
	437	}
	438
	439	/**
	440	* pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1da177e4	441	* @dev: the PCI device structure to match against
8f7020d3	442	* @drv: the device driver to search for matching PCI device id structures
1da177e4 LT	443	*
1da177e4 LT	444	* Used by a driver to check whether a PCI device present in the
8f7020d3	445	* system is in its list of supported devices. Returns the matching
1da177e4 LT	446	* pci_device_id structure or %NULL if there is no match.
1da177e4 LT	447	*/
75865858	448	static int pci_bus_match(struct device dev, struct device_driver drv)
1da177e4	449	{
75865858 GKH	450	struct pci_dev *pci_dev = to_pci_dev(dev);
75865858 GKH	451	struct pci_driver *pci_drv = to_pci_driver(drv);
1da177e4 LT	452	const struct pci_device_id *found_id;
1da177e4 LT	453
75865858	454	found_id = pci_match_device(pci_drv, pci_dev);
1da177e4 LT	455	if (found_id)
	456	return 1;
	457
75865858	458	return 0;
1da177e4 LT	459	}
	460
	461	/**
	462	* pci_dev_get - increments the reference count of the pci device structure
	463	* @dev: the device being referenced
	464	*
	465	* Each live reference to a device should be refcounted.
	466	*
	467	* Drivers for PCI devices should normally record such references in
	468	* their probe() methods, when they bind to a device, and release
	469	* them by calling pci_dev_put(), in their disconnect() methods.
	470	*
	471	* A pointer to the device with the incremented reference counter is returned.
	472	*/
	473	struct pci_dev pci_dev_get(struct pci_dev dev)
	474	{
	475	if (dev)
	476	get_device(&dev->dev);
	477	return dev;
	478	}
	479
	480	/**
	481	* pci_dev_put - release a use of the pci device structure
	482	* @dev: device that's been disconnected
	483	*
	484	* Must be called when a user of a device is finished with it. When the last
	485	* user of the device calls this function, the memory of the device is freed.
	486	*/
	487	void pci_dev_put(struct pci_dev *dev)
	488	{
	489	if (dev)
	490	put_device(&dev->dev);
	491	}
	492
	493	#ifndef CONFIG_HOTPLUG
312c004d KS	494	int pci_uevent(struct device dev, char *envp, int num_envp,
312c004d KS	495	char *buffer, int buffer_size)
1da177e4 LT	496	{
	497	return -ENODEV;
	498	}
	499	#endif
	500
	501	struct bus_type pci_bus_type = {
	502	.name = "pci",
	503	.match = pci_bus_match,
312c004d	504	.uevent = pci_uevent,
b15d686a RK	505	.probe = pci_device_probe,
b15d686a RK	506	.remove = pci_device_remove,
1da177e4	507	.suspend = pci_device_suspend,
50defa1c	508	.shutdown = pci_device_shutdown,
1da177e4 LT	509	.resume = pci_device_resume,
	510	.dev_attrs = pci_dev_attrs,
	511	};
	512
	513	static int __init pci_driver_init(void)
	514	{
	515	return bus_register(&pci_bus_type);
	516	}
	517
	518	postcore_initcall(pci_driver_init);
	519
75865858	520	EXPORT_SYMBOL(pci_match_id);
1da177e4	521	EXPORT_SYMBOL(pci_match_device);
863b18f4	522	EXPORT_SYMBOL(__pci_register_driver);
1da177e4 LT	523	EXPORT_SYMBOL(pci_unregister_driver);
	524	EXPORT_SYMBOL(pci_dev_driver);
	525	EXPORT_SYMBOL(pci_bus_type);
	526	EXPORT_SYMBOL(pci_dev_get);
	527	EXPORT_SYMBOL(pci_dev_put);