[deliverable/linux.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);
		suspend_report_result(drv->suspend, i);
	} 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 GK	29	#ifdef CONFIG_HOTPLUG
3d3c2ae1 GK	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
02669492	274	if (drv && drv->suspend) {
1da177e4	275	i = drv->suspend(pci_dev, state);
02669492 AM	276	suspend_report_result(drv->suspend, i);
02669492 AM	277	} else {
1da177e4	278	pci_save_state(pci_dev);
02669492	279	}
1da177e4 LT	280	return i;
	281	}
	282
	283
95a62965	284	/*
1da177e4 LT	285	* Default resume method for devices that have no driver provided resume,
	286	* or not even a driver at all.
	287	*/
	288	static void pci_default_resume(struct pci_dev *pci_dev)
	289	{
95a62965 GKH	290	int retval;
95a62965 GKH	291
1da177e4 LT	292	/* restore the PCI config space */
	293	pci_restore_state(pci_dev);
	294	/* if the device was enabled before suspend, reenable */
	295	if (pci_dev->is_enabled)
95a62965	296	retval = pci_enable_device(pci_dev);
1da177e4 LT	297	/* if the device was busmaster before the suspend, make it busmaster again */
	298	if (pci_dev->is_busmaster)
	299	pci_set_master(pci_dev);
	300	}
	301
	302	static int pci_device_resume(struct device * dev)
	303	{
	304	struct pci_dev * pci_dev = to_pci_dev(dev);
	305	struct pci_driver * drv = pci_dev->driver;
	306
	307	if (drv && drv->resume)
	308	drv->resume(pci_dev);
	309	else
	310	pci_default_resume(pci_dev);
	311	return 0;
	312	}
	313
c8958177 GK	314	static void pci_device_shutdown(struct device *dev)
	315	{
	316	struct pci_dev *pci_dev = to_pci_dev(dev);
	317	struct pci_driver *drv = pci_dev->driver;
	318
	319	if (drv && drv->shutdown)
	320	drv->shutdown(pci_dev);
	321	}
1da177e4 LT	322
	323	#define kobj_to_pci_driver(obj) container_of(obj, struct device_driver, kobj)
	324	#define attr_to_driver_attribute(obj) container_of(obj, struct driver_attribute, attr)
	325
	326	static ssize_t
	327	pci_driver_attr_show(struct kobject * kobj, struct attribute attr, char buf)
	328	{
	329	struct device_driver *driver = kobj_to_pci_driver(kobj);
	330	struct driver_attribute *dattr = attr_to_driver_attribute(attr);
fc7e4828	331	ssize_t ret;
1da177e4	332
fc7e4828 DT	333	if (!get_driver(driver))
	334	return -ENODEV;
	335
	336	ret = dattr->show ? dattr->show(driver, buf) : -EIO;
	337
	338	put_driver(driver);
1da177e4 LT	339	return ret;
	340	}
	341
	342	static ssize_t
	343	pci_driver_attr_store(struct kobject * kobj, struct attribute *attr,
	344	const char *buf, size_t count)
	345	{
	346	struct device_driver *driver = kobj_to_pci_driver(kobj);
	347	struct driver_attribute *dattr = attr_to_driver_attribute(attr);
fc7e4828	348	ssize_t ret;
1da177e4	349
fc7e4828 DT	350	if (!get_driver(driver))
	351	return -ENODEV;
	352
	353	ret = dattr->store ? dattr->store(driver, buf, count) : -EIO;
	354
	355	put_driver(driver);
1da177e4 LT	356	return ret;
	357	}
	358
	359	static struct sysfs_ops pci_driver_sysfs_ops = {
	360	.show = pci_driver_attr_show,
	361	.store = pci_driver_attr_store,
	362	};
	363	static struct kobj_type pci_driver_kobj_type = {
	364	.sysfs_ops = &pci_driver_sysfs_ops,
	365	};
	366
1da177e4	367	/**
863b18f4	368	* __pci_register_driver - register a new pci driver
1da177e4	369	* @drv: the driver structure to register
863b18f4	370	* @owner: owner module of drv
1da177e4 LT	371	*
	372	* Adds the driver structure to the list of registered drivers.
	373	* Returns a negative value on error, otherwise 0.
eaae4b3a	374	* If no error occurred, the driver remains registered even if
1da177e4 LT	375	* no device was claimed during registration.
1da177e4 LT	376	*/
863b18f4	377	int __pci_register_driver(struct pci_driver drv, struct module owner)
1da177e4 LT	378	{
	379	int error;
	380
	381	/* initialize common driver fields */
	382	drv->driver.name = drv->name;
	383	drv->driver.bus = &pci_bus_type;
863b18f4	384	drv->driver.owner = owner;
1da177e4	385	drv->driver.kobj.ktype = &pci_driver_kobj_type;
75865858 GKH	386
	387	spin_lock_init(&drv->dynids.lock);
	388	INIT_LIST_HEAD(&drv->dynids.list);
1da177e4 LT	389
	390	/* register with core */
	391	error = driver_register(&drv->driver);
	392
	393	if (!error)
75865858	394	error = pci_create_newid_file(drv);
1da177e4 LT	395
	396	return error;
	397	}
	398
	399	/**
	400	* pci_unregister_driver - unregister a pci driver
	401	* @drv: the driver structure to unregister
	402	*
	403	* Deletes the driver structure from the list of registered PCI drivers,
	404	* gives it a chance to clean up by calling its remove() function for
	405	* each device it was responsible for, and marks those devices as
	406	* driverless.
	407	*/
	408
	409	void
	410	pci_unregister_driver(struct pci_driver *drv)
	411	{
	412	driver_unregister(&drv->driver);
	413	pci_free_dynids(drv);
	414	}
	415
	416	static struct pci_driver pci_compat_driver = {
	417	.name = "compat"
	418	};
	419
	420	/**
	421	* pci_dev_driver - get the pci_driver of a device
	422	* @dev: the device to query
	423	*
	424	* Returns the appropriate pci_driver structure or %NULL if there is no
	425	* registered driver for the device.
	426	*/
	427	struct pci_driver *
	428	pci_dev_driver(const struct pci_dev *dev)
	429	{
	430	if (dev->driver)
	431	return dev->driver;
	432	else {
	433	int i;
	434	for(i=0; i<=PCI_ROM_RESOURCE; i++)
	435	if (dev->resource[i].flags & IORESOURCE_BUSY)
	436	return &pci_compat_driver;
	437	}
	438	return NULL;
	439	}
	440
	441	/**
	442	* pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1da177e4	443	* @dev: the PCI device structure to match against
8f7020d3	444	* @drv: the device driver to search for matching PCI device id structures
1da177e4 LT	445	*
1da177e4 LT	446	* Used by a driver to check whether a PCI device present in the
8f7020d3	447	* system is in its list of supported devices. Returns the matching
1da177e4 LT	448	* pci_device_id structure or %NULL if there is no match.
1da177e4 LT	449	*/
75865858	450	static int pci_bus_match(struct device dev, struct device_driver drv)
1da177e4	451	{
75865858 GKH	452	struct pci_dev *pci_dev = to_pci_dev(dev);
75865858 GKH	453	struct pci_driver *pci_drv = to_pci_driver(drv);
1da177e4 LT	454	const struct pci_device_id *found_id;
1da177e4 LT	455
75865858	456	found_id = pci_match_device(pci_drv, pci_dev);
1da177e4 LT	457	if (found_id)
	458	return 1;
	459
75865858	460	return 0;
1da177e4 LT	461	}
	462
	463	/**
	464	* pci_dev_get - increments the reference count of the pci device structure
	465	* @dev: the device being referenced
	466	*
	467	* Each live reference to a device should be refcounted.
	468	*
	469	* Drivers for PCI devices should normally record such references in
	470	* their probe() methods, when they bind to a device, and release
	471	* them by calling pci_dev_put(), in their disconnect() methods.
	472	*
	473	* A pointer to the device with the incremented reference counter is returned.
	474	*/
	475	struct pci_dev pci_dev_get(struct pci_dev dev)
	476	{
	477	if (dev)
	478	get_device(&dev->dev);
	479	return dev;
	480	}
	481
	482	/**
	483	* pci_dev_put - release a use of the pci device structure
	484	* @dev: device that's been disconnected
	485	*
	486	* Must be called when a user of a device is finished with it. When the last
	487	* user of the device calls this function, the memory of the device is freed.
	488	*/
	489	void pci_dev_put(struct pci_dev *dev)
	490	{
	491	if (dev)
	492	put_device(&dev->dev);
	493	}
	494
	495	#ifndef CONFIG_HOTPLUG
312c004d KS	496	int pci_uevent(struct device dev, char *envp, int num_envp,
312c004d KS	497	char *buffer, int buffer_size)
1da177e4 LT	498	{
	499	return -ENODEV;
	500	}
	501	#endif
	502
	503	struct bus_type pci_bus_type = {
	504	.name = "pci",
	505	.match = pci_bus_match,
312c004d	506	.uevent = pci_uevent,
b15d686a RK	507	.probe = pci_device_probe,
b15d686a RK	508	.remove = pci_device_remove,
1da177e4	509	.suspend = pci_device_suspend,
50defa1c	510	.shutdown = pci_device_shutdown,
1da177e4 LT	511	.resume = pci_device_resume,
	512	.dev_attrs = pci_dev_attrs,
	513	};
	514
	515	static int __init pci_driver_init(void)
	516	{
	517	return bus_register(&pci_bus_type);
	518	}
	519
	520	postcore_initcall(pci_driver_init);
	521
75865858	522	EXPORT_SYMBOL(pci_match_id);
1da177e4	523	EXPORT_SYMBOL(pci_match_device);
863b18f4	524	EXPORT_SYMBOL(__pci_register_driver);
1da177e4 LT	525	EXPORT_SYMBOL(pci_unregister_driver);
	526	EXPORT_SYMBOL(pci_dev_driver);
	527	EXPORT_SYMBOL(pci_bus_type);
	528	EXPORT_SYMBOL(pci_dev_get);
	529	EXPORT_SYMBOL(pci_dev_put);