[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 "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 inline 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 = kmalloc(sizeof(*dynid), GFP_KERNEL);
	if (!dynid)
		return -ENOMEM;

	memset(dynid, 0, sizeof(*dynid));
	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
 * 
 * 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)
{
	int error;

	/* initialize common driver fields */
	drv->driver.name = drv->name;
	drv->driver.bus = &pci_bus_type;
	drv->driver.probe = pci_device_probe;
	drv->driver.remove = pci_device_remove;
	/* FIXME, once all of the existing PCI drivers have been fixed to set
	 * the pci shutdown function, this test can go away. */
	if (!drv->driver.shutdown)
		drv->driver.shutdown = pci_device_shutdown;
	else
		printk(KERN_WARNING "Warning: PCI driver %s has a struct "
			"device_driver shutdown method, please update!\n",
			drv->name);
	drv->driver.owner = drv->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_hotplug (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,
	.hotplug	= pci_hotplug,
	.suspend	= pci_device_suspend,
	.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>
1da177e4 LT	13	#include "pci.h"
	14
	15	/*
	16	* Registration of PCI drivers and handling of hot-pluggable devices.
	17	*/
	18
	19	/*
	20	* Dynamic device IDs are disabled for !CONFIG_HOTPLUG
	21	*/
	22
75865858 GKH	23	struct pci_dynid {
	24	struct list_head node;
	25	struct pci_device_id id;
	26	};
1da177e4	27
3d3c2ae1 GK	28	#ifdef CONFIG_HOTPLUG
3d3c2ae1 GK	29
1da177e4	30	/**
8f7020d3 RD	31	* store_new_id - add a new PCI device ID to this driver and re-probe devices
	32	* @driver: target device driver
	33	* @buf: buffer for scanning device ID data
	34	* @count: input size
1da177e4 LT	35	*
	36	* Adds a new dynamic pci device ID to this driver,
	37	* and causes the driver to probe for all devices again.
	38	*/
	39	static inline ssize_t
	40	store_new_id(struct device_driver driver, const char buf, size_t count)
	41	{
75865858	42	struct pci_dynid *dynid;
1da177e4 LT	43	struct pci_driver *pdrv = to_pci_driver(driver);
	44	__u32 vendor=PCI_ANY_ID, device=PCI_ANY_ID, subvendor=PCI_ANY_ID,
	45	subdevice=PCI_ANY_ID, class=0, class_mask=0;
	46	unsigned long driver_data=0;
	47	int fields=0;
	48
	49	fields = sscanf(buf, "%x %x %x %x %x %x %lux",
	50	&vendor, &device, &subvendor, &subdevice,
	51	&class, &class_mask, &driver_data);
	52	if (fields < 0)
	53	return -EINVAL;
	54
	55	dynid = kmalloc(sizeof(*dynid), GFP_KERNEL);
	56	if (!dynid)
	57	return -ENOMEM;
	58
	59	memset(dynid, 0, sizeof(*dynid));
	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 GK	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 LT	365	/**
	366	* pci_register_driver - register a new pci driver
	367	* @drv: the driver structure to register
	368	*
	369	* Adds the driver structure to the list of registered drivers.
	370	* Returns a negative value on error, otherwise 0.
eaae4b3a	371	* If no error occurred, the driver remains registered even if
1da177e4 LT	372	* no device was claimed during registration.
	373	*/
	374	int pci_register_driver(struct pci_driver *drv)
	375	{
	376	int error;
	377
	378	/* initialize common driver fields */
	379	drv->driver.name = drv->name;
	380	drv->driver.bus = &pci_bus_type;
	381	drv->driver.probe = pci_device_probe;
	382	drv->driver.remove = pci_device_remove;
794f5bfa CH	383	/* FIXME, once all of the existing PCI drivers have been fixed to set
	384	* the pci shutdown function, this test can go away. */
	385	if (!drv->driver.shutdown)
c83d9945	386	drv->driver.shutdown = pci_device_shutdown;
a1720fdb RK	387	else
	388	printk(KERN_WARNING "Warning: PCI driver %s has a struct "
	389	"device_driver shutdown method, please update!\n",
	390	drv->name);
1da177e4 LT	391	drv->driver.owner = drv->owner;
1da177e4 LT	392	drv->driver.kobj.ktype = &pci_driver_kobj_type;
75865858 GKH	393
	394	spin_lock_init(&drv->dynids.lock);
	395	INIT_LIST_HEAD(&drv->dynids.list);
1da177e4 LT	396
	397	/* register with core */
	398	error = driver_register(&drv->driver);
	399
	400	if (!error)
75865858	401	error = pci_create_newid_file(drv);
1da177e4 LT	402
	403	return error;
	404	}
	405
	406	/**
	407	* pci_unregister_driver - unregister a pci driver
	408	* @drv: the driver structure to unregister
	409	*
	410	* Deletes the driver structure from the list of registered PCI drivers,
	411	* gives it a chance to clean up by calling its remove() function for
	412	* each device it was responsible for, and marks those devices as
	413	* driverless.
	414	*/
	415
	416	void
	417	pci_unregister_driver(struct pci_driver *drv)
	418	{
	419	driver_unregister(&drv->driver);
	420	pci_free_dynids(drv);
	421	}
	422
	423	static struct pci_driver pci_compat_driver = {
	424	.name = "compat"
	425	};
	426
	427	/**
	428	* pci_dev_driver - get the pci_driver of a device
	429	* @dev: the device to query
	430	*
	431	* Returns the appropriate pci_driver structure or %NULL if there is no
	432	* registered driver for the device.
	433	*/
	434	struct pci_driver *
	435	pci_dev_driver(const struct pci_dev *dev)
	436	{
	437	if (dev->driver)
	438	return dev->driver;
	439	else {
	440	int i;
	441	for(i=0; i<=PCI_ROM_RESOURCE; i++)
	442	if (dev->resource[i].flags & IORESOURCE_BUSY)
	443	return &pci_compat_driver;
	444	}
	445	return NULL;
	446	}
	447
	448	/**
	449	* pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1da177e4	450	* @dev: the PCI device structure to match against
8f7020d3	451	* @drv: the device driver to search for matching PCI device id structures
1da177e4 LT	452	*
1da177e4 LT	453	* Used by a driver to check whether a PCI device present in the
8f7020d3	454	* system is in its list of supported devices. Returns the matching
1da177e4 LT	455	* pci_device_id structure or %NULL if there is no match.
1da177e4 LT	456	*/
75865858	457	static int pci_bus_match(struct device dev, struct device_driver drv)
1da177e4	458	{
75865858 GKH	459	struct pci_dev *pci_dev = to_pci_dev(dev);
75865858 GKH	460	struct pci_driver *pci_drv = to_pci_driver(drv);
1da177e4 LT	461	const struct pci_device_id *found_id;
1da177e4 LT	462
75865858	463	found_id = pci_match_device(pci_drv, pci_dev);
1da177e4 LT	464	if (found_id)
	465	return 1;
	466
75865858	467	return 0;
1da177e4 LT	468	}
	469
	470	/**
	471	* pci_dev_get - increments the reference count of the pci device structure
	472	* @dev: the device being referenced
	473	*
	474	* Each live reference to a device should be refcounted.
	475	*
	476	* Drivers for PCI devices should normally record such references in
	477	* their probe() methods, when they bind to a device, and release
	478	* them by calling pci_dev_put(), in their disconnect() methods.
	479	*
	480	* A pointer to the device with the incremented reference counter is returned.
	481	*/
	482	struct pci_dev pci_dev_get(struct pci_dev dev)
	483	{
	484	if (dev)
	485	get_device(&dev->dev);
	486	return dev;
	487	}
	488
	489	/**
	490	* pci_dev_put - release a use of the pci device structure
	491	* @dev: device that's been disconnected
	492	*
	493	* Must be called when a user of a device is finished with it. When the last
	494	* user of the device calls this function, the memory of the device is freed.
	495	*/
	496	void pci_dev_put(struct pci_dev *dev)
	497	{
	498	if (dev)
	499	put_device(&dev->dev);
	500	}
	501
	502	#ifndef CONFIG_HOTPLUG
	503	int pci_hotplug (struct device dev, char *envp, int num_envp,
	504	char *buffer, int buffer_size)
	505	{
	506	return -ENODEV;
	507	}
	508	#endif
	509
	510	struct bus_type pci_bus_type = {
	511	.name = "pci",
	512	.match = pci_bus_match,
	513	.hotplug = pci_hotplug,
	514	.suspend = pci_device_suspend,
	515	.resume = pci_device_resume,
	516	.dev_attrs = pci_dev_attrs,
	517	};
	518
	519	static int __init pci_driver_init(void)
	520	{
	521	return bus_register(&pci_bus_type);
	522	}
	523
	524	postcore_initcall(pci_driver_init);
	525
75865858	526	EXPORT_SYMBOL(pci_match_id);
1da177e4 LT	527	EXPORT_SYMBOL(pci_match_device);
	528	EXPORT_SYMBOL(pci_register_driver);
	529	EXPORT_SYMBOL(pci_unregister_driver);
	530	EXPORT_SYMBOL(pci_dev_driver);
	531	EXPORT_SYMBOL(pci_bus_type);
	532	EXPORT_SYMBOL(pci_dev_get);
	533	EXPORT_SYMBOL(pci_dev_put);