Eric Lee / smarc-fsl-linux-kernel

Commit adf094931ffb25ef4b381559918f1a34181a5273

Authored by Rafael J. Wysocki 17 years ago

Committed by Greg Kroah-Hartman 17 years ago

Exists in master and in 39 other branches

PM: Simplify the new suspend/hibernation framework for devices

PM: Simplify the new suspend/hibernation framework for devices

Following the discussion at the Kernel Summit, simplify the new
device PM framework by merging 'struct pm_ops' and
'struct pm_ext_ops' and removing pointers to 'struct pm_ext_ops'
from 'struct platform_driver' and 'struct pci_driver'.

After this change, the suspend/hibernation callbacks will only
reside in 'struct device_driver' as well as at the bus type/
device class/device type level.  Accordingly, PCI and platform
device drivers are now expected to put their suspend/hibernation
callbacks into the 'struct device_driver' embedded in
'struct pci_driver' or 'struct platform_driver', respectively.

Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Acked-by: Pavel Machek <pavel@suse.cz>
Cc: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

Showing 8 changed files with 119 additions and 151 deletions Inline Diff

drivers/base/platform.c
drivers/base/power/main.c
drivers/pci/pci-driver.c
drivers/usb/core/usb.c
include/linux/device.h
include/linux/pci.h
include/linux/platform_device.h
include/linux/pm.h

drivers/base/platform.c

Diff comments View file @ adf0949

 /*
  * platform.c - platform 'pseudo' bus for legacy devices
  *
  * Copyright (c) 2002-3 Patrick Mochel
  * Copyright (c) 2002-3 Open Source Development Labs
  *
  * This file is released under the GPLv2
  *
  * Please see Documentation/driver-model/platform.txt for more
  * information.
  */
 #include <linux/platform_device.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/dma-mapping.h>
 #include <linux/bootmem.h>
 #include <linux/err.h>
 #include <linux/slab.h>
 #include "base.h"
 #define to_platform_driver(drv)	(container_of((drv), struct platform_driver, \
 				 driver))
 struct device platform_bus = {
 	.bus_id		= "platform",
 };
 EXPORT_SYMBOL_GPL(platform_bus);
 /**
  * platform_get_resource - get a resource for a device
  * @dev: platform device
  * @type: resource type
  * @num: resource index
  */
 struct resource *platform_get_resource(struct platform_device *dev,
 				       unsigned int type, unsigned int num)
 {
 	int i;
 	for (i = 0; i < dev->num_resources; i++) {
 		struct resource *r = &dev->resource[i];
 		if (type == resource_type(r) && num-- == 0)
 			return r;
 	}
 	return NULL;
 }
 EXPORT_SYMBOL_GPL(platform_get_resource);
 /**
  * platform_get_irq - get an IRQ for a device
  * @dev: platform device
  * @num: IRQ number index
  */
 int platform_get_irq(struct platform_device *dev, unsigned int num)
 {
 	struct resource *r = platform_get_resource(dev, IORESOURCE_IRQ, num);
 	return r ? r->start : -ENXIO;
 }
 EXPORT_SYMBOL_GPL(platform_get_irq);
 /**
  * platform_get_resource_byname - get a resource for a device by name
  * @dev: platform device
  * @type: resource type
  * @name: resource name
  */
 struct resource *platform_get_resource_byname(struct platform_device *dev,
 					      unsigned int type, char *name)
 {
 	int i;
 	for (i = 0; i < dev->num_resources; i++) {
 		struct resource *r = &dev->resource[i];
 		if (type == resource_type(r) && !strcmp(r->name, name))
 			return r;
 	}
 	return NULL;
 }
 EXPORT_SYMBOL_GPL(platform_get_resource_byname);
 /**
  * platform_get_irq - get an IRQ for a device
  * @dev: platform device
  * @name: IRQ name
  */
 int platform_get_irq_byname(struct platform_device *dev, char *name)
 {
 	struct resource *r = platform_get_resource_byname(dev, IORESOURCE_IRQ,
 							  name);
 	return r ? r->start : -ENXIO;
 }
 EXPORT_SYMBOL_GPL(platform_get_irq_byname);
 /**
  * platform_add_devices - add a numbers of platform devices
  * @devs: array of platform devices to add
  * @num: number of platform devices in array
  */
 int platform_add_devices(struct platform_device **devs, int num)
 {
 	int i, ret = 0;
 	for (i = 0; i < num; i++) {
 		ret = platform_device_register(devs[i]);
 		if (ret) {
 			while (--i >= 0)
 				platform_device_unregister(devs[i]);
 			break;
 		}
 	}
 	return ret;
 }
 EXPORT_SYMBOL_GPL(platform_add_devices);
 struct platform_object {
 	struct platform_device pdev;
 	char name[1];
 };
 /**
  * platform_device_put
  * @pdev: platform device to free
  *
  * Free all memory associated with a platform device.  This function must
  * _only_ be externally called in error cases.  All other usage is a bug.
  */
 void platform_device_put(struct platform_device *pdev)
 {
 	if (pdev)
 		put_device(&pdev->dev);
 }
 EXPORT_SYMBOL_GPL(platform_device_put);
 static void platform_device_release(struct device *dev)
 {
 	struct platform_object *pa = container_of(dev, struct platform_object,
 						  pdev.dev);
 	kfree(pa->pdev.dev.platform_data);
 	kfree(pa->pdev.resource);
 	kfree(pa);
 }
 /**
  * platform_device_alloc
  * @name: base name of the device we're adding
  * @id: instance id
  *
  * Create a platform device object which can have other objects attached
  * to it, and which will have attached objects freed when it is released.
  */
 struct platform_device *platform_device_alloc(const char *name, int id)
 {
 	struct platform_object *pa;
 	pa = kzalloc(sizeof(struct platform_object) + strlen(name), GFP_KERNEL);
 	if (pa) {
 		strcpy(pa->name, name);
 		pa->pdev.name = pa->name;
 		pa->pdev.id = id;
 		device_initialize(&pa->pdev.dev);
 		pa->pdev.dev.release = platform_device_release;
 	}
 	return pa ? &pa->pdev : NULL;
 }
 EXPORT_SYMBOL_GPL(platform_device_alloc);
 /**
  * platform_device_add_resources
  * @pdev: platform device allocated by platform_device_alloc to add resources to
  * @res: set of resources that needs to be allocated for the device
  * @num: number of resources
  *
  * Add a copy of the resources to the platform device.  The memory
  * associated with the resources will be freed when the platform device is
  * released.
  */
 int platform_device_add_resources(struct platform_device *pdev,
 				  struct resource *res, unsigned int num)
 {
 	struct resource *r;
 	r = kmalloc(sizeof(struct resource) * num, GFP_KERNEL);
 	if (r) {
 		memcpy(r, res, sizeof(struct resource) * num);
 		pdev->resource = r;
 		pdev->num_resources = num;
 	}
 	return r ? 0 : -ENOMEM;
 }
 EXPORT_SYMBOL_GPL(platform_device_add_resources);
 /**
  * platform_device_add_data
  * @pdev: platform device allocated by platform_device_alloc to add resources to
  * @data: platform specific data for this platform device
  * @size: size of platform specific data
  *
  * Add a copy of platform specific data to the platform device's
  * platform_data pointer.  The memory associated with the platform data
  * will be freed when the platform device is released.
  */
 int platform_device_add_data(struct platform_device *pdev, const void *data,
 			     size_t size)
 {
 	void *d;
 	d = kmalloc(size, GFP_KERNEL);
 	if (d) {
 		memcpy(d, data, size);
 		pdev->dev.platform_data = d;
 	}
 	return d ? 0 : -ENOMEM;
 }
 EXPORT_SYMBOL_GPL(platform_device_add_data);
 /**
  * platform_device_add - add a platform device to device hierarchy
  * @pdev: platform device we're adding
  *
  * This is part 2 of platform_device_register(), though may be called
  * separately _iff_ pdev was allocated by platform_device_alloc().
  */
 int platform_device_add(struct platform_device *pdev)
 {
 	int i, ret = 0;
 	if (!pdev)
 		return -EINVAL;
 	if (!pdev->dev.parent)
 		pdev->dev.parent = &platform_bus;
 	pdev->dev.bus = &platform_bus_type;
 	if (pdev->id != -1)
 		snprintf(pdev->dev.bus_id, BUS_ID_SIZE, "%s.%d", pdev->name,
 			 pdev->id);
 	else
 		strlcpy(pdev->dev.bus_id, pdev->name, BUS_ID_SIZE);
 	for (i = 0; i < pdev->num_resources; i++) {
 		struct resource *p, *r = &pdev->resource[i];
 		if (r->name == NULL)
 			r->name = pdev->dev.bus_id;
 		p = r->parent;
 		if (!p) {
 			if (resource_type(r) == IORESOURCE_MEM)
 				p = &iomem_resource;
 			else if (resource_type(r) == IORESOURCE_IO)
 				p = &ioport_resource;
 		}
 		if (p && insert_resource(p, r)) {
 			printk(KERN_ERR
 			       "%s: failed to claim resource %d\n",
 			       pdev->dev.bus_id, i);
 			ret = -EBUSY;
 			goto failed;
 		}
 	}
 	pr_debug("Registering platform device '%s'. Parent at %s\n",
 		 pdev->dev.bus_id, pdev->dev.parent->bus_id);
 	ret = device_add(&pdev->dev);
 	if (ret == 0)
 		return ret;
  failed:
 	while (--i >= 0) {
 		struct resource *r = &pdev->resource[i];
 		unsigned long type = resource_type(r);
 		if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
 			release_resource(r);
 	}
 	return ret;
 }
 EXPORT_SYMBOL_GPL(platform_device_add);
 /**
  * platform_device_del - remove a platform-level device
  * @pdev: platform device we're removing
  *
  * Note that this function will also release all memory- and port-based
  * resources owned by the device (@dev->resource).  This function must
  * _only_ be externally called in error cases.  All other usage is a bug.
  */
 void platform_device_del(struct platform_device *pdev)
 {
 	int i;
 	if (pdev) {
 		device_del(&pdev->dev);
 		for (i = 0; i < pdev->num_resources; i++) {
 			struct resource *r = &pdev->resource[i];
 			unsigned long type = resource_type(r);
 			if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
 				release_resource(r);
 		}
 	}
 }
 EXPORT_SYMBOL_GPL(platform_device_del);
 /**
  * platform_device_register - add a platform-level device
  * @pdev: platform device we're adding
  */
 int platform_device_register(struct platform_device *pdev)
 {
 	device_initialize(&pdev->dev);
 	return platform_device_add(pdev);
 }
 EXPORT_SYMBOL_GPL(platform_device_register);
 /**
  * platform_device_unregister - unregister a platform-level device
  * @pdev: platform device we're unregistering
  *
  * Unregistration is done in 2 steps. First we release all resources
  * and remove it from the subsystem, then we drop reference count by
  * calling platform_device_put().
  */
 void platform_device_unregister(struct platform_device *pdev)
 {
 	platform_device_del(pdev);
 	platform_device_put(pdev);
 }
 EXPORT_SYMBOL_GPL(platform_device_unregister);
 /**
  * platform_device_register_simple
  * @name: base name of the device we're adding
  * @id: instance id
  * @res: set of resources that needs to be allocated for the device
  * @num: number of resources
  *
  * This function creates a simple platform device that requires minimal
  * resource and memory management. Canned release function freeing memory
  * allocated for the device allows drivers using such devices to be
  * unloaded without waiting for the last reference to the device to be
  * dropped.
  *
  * This interface is primarily intended for use with legacy drivers which
  * probe hardware directly.  Because such drivers create sysfs device nodes
  * themselves, rather than letting system infrastructure handle such device
  * enumeration tasks, they don't fully conform to the Linux driver model.
  * In particular, when such drivers are built as modules, they can't be
  * "hotplugged".
  */
 struct platform_device *platform_device_register_simple(const char *name,
 							int id,
 							struct resource *res,
 							unsigned int num)
 {
 	struct platform_device *pdev;
 	int retval;
 	pdev = platform_device_alloc(name, id);
 	if (!pdev) {
 		retval = -ENOMEM;
 		goto error;
 	}
 	if (num) {
 		retval = platform_device_add_resources(pdev, res, num);
 		if (retval)
 			goto error;
 	}
 	retval = platform_device_add(pdev);
 	if (retval)
 		goto error;
 	return pdev;
 error:
 	platform_device_put(pdev);
 	return ERR_PTR(retval);
 }
 EXPORT_SYMBOL_GPL(platform_device_register_simple);
 /**
  * platform_device_register_data
  * @parent: parent device for the device we're adding
  * @name: base name of the device we're adding
  * @id: instance id
  * @data: platform specific data for this platform device
  * @size: size of platform specific data
  *
  * This function creates a simple platform device that requires minimal
  * resource and memory management. Canned release function freeing memory
  * allocated for the device allows drivers using such devices to be
  * unloaded without waiting for the last reference to the device to be
  * dropped.
  */
 struct platform_device *platform_device_register_data(
 		struct device *parent,
 		const char *name, int id,
 		const void *data, size_t size)
 {
 	struct platform_device *pdev;
 	int retval;
 	pdev = platform_device_alloc(name, id);
 	if (!pdev) {
 		retval = -ENOMEM;
 		goto error;
 	}
 	pdev->dev.parent = parent;
 	if (size) {
 		retval = platform_device_add_data(pdev, data, size);
 		if (retval)
 			goto error;
 	}
 	retval = platform_device_add(pdev);
 	if (retval)
 		goto error;
 	return pdev;
 error:
 	platform_device_put(pdev);
 	return ERR_PTR(retval);
 }
 static int platform_drv_probe(struct device *_dev)
 {
 	struct platform_driver *drv = to_platform_driver(_dev->driver);
 	struct platform_device *dev = to_platform_device(_dev);
 	return drv->probe(dev);
 }
 static int platform_drv_probe_fail(struct device *_dev)
 {
 	return -ENXIO;
 }
 static int platform_drv_remove(struct device *_dev)
 {
 	struct platform_driver *drv = to_platform_driver(_dev->driver);
 	struct platform_device *dev = to_platform_device(_dev);
 	return drv->remove(dev);
 }
 static void platform_drv_shutdown(struct device *_dev)
 {
 	struct platform_driver *drv = to_platform_driver(_dev->driver);
 	struct platform_device *dev = to_platform_device(_dev);
 	drv->shutdown(dev);
 }
 static int platform_drv_suspend(struct device *_dev, pm_message_t state)
 {
 	struct platform_driver *drv = to_platform_driver(_dev->driver);
 	struct platform_device *dev = to_platform_device(_dev);
 	return drv->suspend(dev, state);
 }
 static int platform_drv_resume(struct device *_dev)
 {
 	struct platform_driver *drv = to_platform_driver(_dev->driver);
 	struct platform_device *dev = to_platform_device(_dev);
 	return drv->resume(dev);
 }
 /**
  * platform_driver_register
  * @drv: platform driver structure
  */
 int platform_driver_register(struct platform_driver *drv)
 {
 	drv->driver.bus = &platform_bus_type;
 	if (drv->probe)
 		drv->driver.probe = platform_drv_probe;
 	if (drv->remove)
 		drv->driver.remove = platform_drv_remove;
 	if (drv->shutdown)
 		drv->driver.shutdown = platform_drv_shutdown;
 	if (drv->suspend)
 		drv->driver.suspend = platform_drv_suspend;
 	if (drv->resume)
 		drv->driver.resume = platform_drv_resume;
-	if (drv->pm)
-		drv->driver.pm = &drv->pm->base;
 	return driver_register(&drv->driver);
 }
 EXPORT_SYMBOL_GPL(platform_driver_register);
 /**
  * platform_driver_unregister
  * @drv: platform driver structure
  */
 void platform_driver_unregister(struct platform_driver *drv)
 {
 	driver_unregister(&drv->driver);
 }
 EXPORT_SYMBOL_GPL(platform_driver_unregister);
 /**
  * platform_driver_probe - register driver for non-hotpluggable device
  * @drv: platform driver structure
  * @probe: the driver probe routine, probably from an __init section
  *
  * Use this instead of platform_driver_register() when you know the device
  * is not hotpluggable and has already been registered, and you want to
  * remove its run-once probe() infrastructure from memory after the driver
  * has bound to the device.
  *
  * One typical use for this would be with drivers for controllers integrated
  * into system-on-chip processors, where the controller devices have been
  * configured as part of board setup.
  *
  * Returns zero if the driver registered and bound to a device, else returns
  * a negative error code and with the driver not registered.
  */
 int __init_or_module platform_driver_probe(struct platform_driver *drv,
 		int (*probe)(struct platform_device *))
 {
 	int retval, code;
 	/* temporary section violation during probe() */
 	drv->probe = probe;
 	retval = code = platform_driver_register(drv);
 	/* Fixup that section violation, being paranoid about code scanning
 	 * the list of drivers in order to probe new devices.  Check to see
 	 * if the probe was successful, and make sure any forced probes of
 	 * new devices fail.
 	 */
 	spin_lock(&platform_bus_type.p->klist_drivers.k_lock);
 	drv->probe = NULL;
 	if (code == 0 && list_empty(&drv->driver.p->klist_devices.k_list))
 		retval = -ENODEV;
 	drv->driver.probe = platform_drv_probe_fail;
 	spin_unlock(&platform_bus_type.p->klist_drivers.k_lock);
 	if (code != retval)
 		platform_driver_unregister(drv);
 	return retval;
 }
 EXPORT_SYMBOL_GPL(platform_driver_probe);
 /* modalias support enables more hands-off userspace setup:
  * (a) environment variable lets new-style hotplug events work once system is
  *     fully running:  "modprobe $MODALIAS"
  * (b) sysfs attribute lets new-style coldplug recover from hotplug events
  *     mishandled before system is fully running:  "modprobe $(cat modalias)"
  */
 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
 			     char *buf)
 {
 	struct platform_device	*pdev = to_platform_device(dev);
 	int len = snprintf(buf, PAGE_SIZE, "platform:%s\n", pdev->name);
 	return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
 }
 static struct device_attribute platform_dev_attrs[] = {
 	__ATTR_RO(modalias),
 	__ATTR_NULL,
 };
 static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
 	struct platform_device	*pdev = to_platform_device(dev);
 	add_uevent_var(env, "MODALIAS=platform:%s", pdev->name);
 	return 0;
 }
 /**
  * platform_match - bind platform device to platform driver.
  * @dev: device.
  * @drv: driver.
  *
  * Platform device IDs are assumed to be encoded like this:
  * "<name><instance>", where <name> is a short description of the type of
  * device, like "pci" or "floppy", and <instance> is the enumerated
  * instance of the device, like '0' or '42'.  Driver IDs are simply
  * "<name>".  So, extract the <name> from the platform_device structure,
  * and compare it against the name of the driver. Return whether they match
  * or not.
  */
 static int platform_match(struct device *dev, struct device_driver *drv)
 {
 	struct platform_device *pdev;
 	pdev = container_of(dev, struct platform_device, dev);
 	return (strncmp(pdev->name, drv->name, BUS_ID_SIZE) == 0);
 }
 #ifdef CONFIG_PM_SLEEP
 static int platform_legacy_suspend(struct device *dev, pm_message_t mesg)
 {
 	int ret = 0;
 	if (dev->driver && dev->driver->suspend)
 		ret = dev->driver->suspend(dev, mesg);
 	return ret;
 }
 static int platform_legacy_suspend_late(struct device *dev, pm_message_t mesg)
 {
 	struct platform_driver *drv = to_platform_driver(dev->driver);
 	struct platform_device *pdev;
 	int ret = 0;
 	pdev = container_of(dev, struct platform_device, dev);
 	if (dev->driver && drv->suspend_late)
 		ret = drv->suspend_late(pdev, mesg);
 	return ret;
 }
 static int platform_legacy_resume_early(struct device *dev)
 {
 	struct platform_driver *drv = to_platform_driver(dev->driver);
 	struct platform_device *pdev;
 	int ret = 0;
 	pdev = container_of(dev, struct platform_device, dev);
 	if (dev->driver && drv->resume_early)
 		ret = drv->resume_early(pdev);
 	return ret;
 }
 static int platform_legacy_resume(struct device *dev)
 {
 	int ret = 0;
 	if (dev->driver && dev->driver->resume)
 		ret = dev->driver->resume(dev);
 	return ret;
 }
 static int platform_pm_prepare(struct device *dev)
 {
 	struct device_driver *drv = dev->driver;
 	int ret = 0;
 	if (drv && drv->pm && drv->pm->prepare)
 		ret = drv->pm->prepare(dev);
 	return ret;
 }
 static void platform_pm_complete(struct device *dev)
 {
 	struct device_driver *drv = dev->driver;
 	if (drv && drv->pm && drv->pm->complete)
 		drv->pm->complete(dev);
 }
 #ifdef CONFIG_SUSPEND
 static int platform_pm_suspend(struct device *dev)
 {
 	struct device_driver *drv = dev->driver;
 	int ret = 0;
-	if (drv && drv->pm) {
+	if (!drv)
+		return 0;
+	if (drv->pm) {
 		if (drv->pm->suspend)
 			ret = drv->pm->suspend(dev);
 	} else {
 		ret = platform_legacy_suspend(dev, PMSG_SUSPEND);
 	}
 	return ret;
 }
 static int platform_pm_suspend_noirq(struct device *dev)
 {
-	struct platform_driver *pdrv;
+	struct device_driver *drv = dev->driver;
 	int ret = 0;
-	if (!dev->driver)
+	if (!drv)
 		return 0;
-	pdrv = to_platform_driver(dev->driver);
+	if (drv->pm) {
-	if (pdrv->pm) {
+		if (drv->pm->suspend_noirq)
-		if (pdrv->pm->suspend_noirq)
+			ret = drv->pm->suspend_noirq(dev);
-			ret = pdrv->pm->suspend_noirq(dev);
 	} else {
 		ret = platform_legacy_suspend_late(dev, PMSG_SUSPEND);
 	}
 	return ret;
 }
 static int platform_pm_resume(struct device *dev)
 {
 	struct device_driver *drv = dev->driver;
 	int ret = 0;
-	if (drv && drv->pm) {
+	if (!drv)
+		return 0;
+	if (drv->pm) {
 		if (drv->pm->resume)
 			ret = drv->pm->resume(dev);
 	} else {
 		ret = platform_legacy_resume(dev);
 	}
 	return ret;
 }
 static int platform_pm_resume_noirq(struct device *dev)
 {
-	struct platform_driver *pdrv;
+	struct device_driver *drv = dev->driver;
 	int ret = 0;
-	if (!dev->driver)
+	if (!drv)
 		return 0;
-	pdrv = to_platform_driver(dev->driver);
+	if (drv->pm) {
-	if (pdrv->pm) {
+		if (drv->pm->resume_noirq)
-		if (pdrv->pm->resume_noirq)
+			ret = drv->pm->resume_noirq(dev);
-			ret = pdrv->pm->resume_noirq(dev);
 	} else {
 		ret = platform_legacy_resume_early(dev);
 	}
 	return ret;
 }
 #else /* !CONFIG_SUSPEND */
 #define platform_pm_suspend		NULL
 #define platform_pm_resume		NULL
 #define platform_pm_suspend_noirq	NULL
 #define platform_pm_resume_noirq	NULL
 #endif /* !CONFIG_SUSPEND */
 #ifdef CONFIG_HIBERNATION
 static int platform_pm_freeze(struct device *dev)
 {
 	struct device_driver *drv = dev->driver;
 	int ret = 0;
 	if (!drv)
 		return 0;
 	if (drv->pm) {
 		if (drv->pm->freeze)
 			ret = drv->pm->freeze(dev);
 	} else {
 		ret = platform_legacy_suspend(dev, PMSG_FREEZE);
 	}
 	return ret;
 }
 static int platform_pm_freeze_noirq(struct device *dev)
 {
-	struct platform_driver *pdrv;
+	struct device_driver *drv = dev->driver;
 	int ret = 0;
-	if (!dev->driver)
+	if (!drv)
 		return 0;
-	pdrv = to_platform_driver(dev->driver);
+	if (drv->pm) {
-	if (pdrv->pm) {
+		if (drv->pm->freeze_noirq)
-		if (pdrv->pm->freeze_noirq)
+			ret = drv->pm->freeze_noirq(dev);
-			ret = pdrv->pm->freeze_noirq(dev);
 	} else {
 		ret = platform_legacy_suspend_late(dev, PMSG_FREEZE);
 	}
 	return ret;
 }
 static int platform_pm_thaw(struct device *dev)
 {
 	struct device_driver *drv = dev->driver;
 	int ret = 0;
-	if (drv && drv->pm) {
+	if (!drv)
+		return 0;
+	if (drv->pm) {
 		if (drv->pm->thaw)
 			ret = drv->pm->thaw(dev);
 	} else {
 		ret = platform_legacy_resume(dev);
 	}
 	return ret;
 }
 static int platform_pm_thaw_noirq(struct device *dev)
 {
-	struct platform_driver *pdrv;
+	struct device_driver *drv = dev->driver;
 	int ret = 0;
-	if (!dev->driver)
+	if (!drv)
 		return 0;
-	pdrv = to_platform_driver(dev->driver);
+	if (drv->pm) {
-	if (pdrv->pm) {
+		if (drv->pm->thaw_noirq)
-		if (pdrv->pm->thaw_noirq)
+			ret = drv->pm->thaw_noirq(dev);
-			ret = pdrv->pm->thaw_noirq(dev);
 	} else {
 		ret = platform_legacy_resume_early(dev);
 	}
 	return ret;
 }
 static int platform_pm_poweroff(struct device *dev)
 {
 	struct device_driver *drv = dev->driver;
 	int ret = 0;
-	if (drv && drv->pm) {
+	if (!drv)
+		return 0;
+	if (drv->pm) {
 		if (drv->pm->poweroff)
 			ret = drv->pm->poweroff(dev);
 	} else {
 		ret = platform_legacy_suspend(dev, PMSG_HIBERNATE);
 	}
 	return ret;
 }
 static int platform_pm_poweroff_noirq(struct device *dev)
 {
-	struct platform_driver *pdrv;
+	struct device_driver *drv = dev->driver;
 	int ret = 0;
-	if (!dev->driver)
+	if (!drv)
 		return 0;
-	pdrv = to_platform_driver(dev->driver);
+	if (drv->pm) {
-	if (pdrv->pm) {
+		if (drv->pm->poweroff_noirq)
-		if (pdrv->pm->poweroff_noirq)
+			ret = drv->pm->poweroff_noirq(dev);
-			ret = pdrv->pm->poweroff_noirq(dev);
 	} else {
 		ret = platform_legacy_suspend_late(dev, PMSG_HIBERNATE);
 	}
 	return ret;
 }
 static int platform_pm_restore(struct device *dev)
 {
 	struct device_driver *drv = dev->driver;
 	int ret = 0;
-	if (drv && drv->pm) {
+	if (!drv)
+		return 0;
+	if (drv->pm) {
 		if (drv->pm->restore)
 			ret = drv->pm->restore(dev);
 	} else {
 		ret = platform_legacy_resume(dev);
 	}
 	return ret;
 }
 static int platform_pm_restore_noirq(struct device *dev)
 {
-	struct platform_driver *pdrv;
+	struct device_driver *drv = dev->driver;
 	int ret = 0;
-	if (!dev->driver)
+	if (!drv)
 		return 0;
-	pdrv = to_platform_driver(dev->driver);
+	if (drv->pm) {
-	if (pdrv->pm) {
+		if (drv->pm->restore_noirq)
-		if (pdrv->pm->restore_noirq)
+			ret = drv->pm->restore_noirq(dev);
-			ret = pdrv->pm->restore_noirq(dev);
 	} else {
 		ret = platform_legacy_resume_early(dev);
 	}
 	return ret;
 }
 #else /* !CONFIG_HIBERNATION */
 #define platform_pm_freeze		NULL
 #define platform_pm_thaw		NULL
 #define platform_pm_poweroff		NULL
 #define platform_pm_restore		NULL
 #define platform_pm_freeze_noirq	NULL
 #define platform_pm_thaw_noirq		NULL
 #define platform_pm_poweroff_noirq	NULL
 #define platform_pm_restore_noirq	NULL
 #endif /* !CONFIG_HIBERNATION */
-static struct pm_ext_ops platform_pm_ops = {
+static struct dev_pm_ops platform_dev_pm_ops = {
-	.base = {
+	.prepare = platform_pm_prepare,
-		.prepare = platform_pm_prepare,
+	.complete = platform_pm_complete,
-		.complete = platform_pm_complete,
+	.suspend = platform_pm_suspend,
-		.suspend = platform_pm_suspend,
+	.resume = platform_pm_resume,
-		.resume = platform_pm_resume,
+	.freeze = platform_pm_freeze,
-		.freeze = platform_pm_freeze,
+	.thaw = platform_pm_thaw,
-		.thaw = platform_pm_thaw,
+	.poweroff = platform_pm_poweroff,
-		.poweroff = platform_pm_poweroff,
+	.restore = platform_pm_restore,
-		.restore = platform_pm_restore,
-	},
 	.suspend_noirq = platform_pm_suspend_noirq,
 	.resume_noirq = platform_pm_resume_noirq,
 	.freeze_noirq = platform_pm_freeze_noirq,
 	.thaw_noirq = platform_pm_thaw_noirq,
 	.poweroff_noirq = platform_pm_poweroff_noirq,
 	.restore_noirq = platform_pm_restore_noirq,
 };
-#define PLATFORM_PM_OPS_PTR	&platform_pm_ops
+#define PLATFORM_PM_OPS_PTR	(&platform_dev_pm_ops)
 #else /* !CONFIG_PM_SLEEP */
 #define PLATFORM_PM_OPS_PTR	NULL
 #endif /* !CONFIG_PM_SLEEP */
 struct bus_type platform_bus_type = {
 	.name		= "platform",
 	.dev_attrs	= platform_dev_attrs,
 	.match		= platform_match,
 	.uevent		= platform_uevent,
 	.pm		= PLATFORM_PM_OPS_PTR,
 };
 EXPORT_SYMBOL_GPL(platform_bus_type);
 int __init platform_bus_init(void)
 {
 	int error;
 	error = device_register(&platform_bus);
 	if (error)
 		return error;
 	error =  bus_register(&platform_bus_type);
 	if (error)
 		device_unregister(&platform_bus);
 	return error;
 }
 #ifndef ARCH_HAS_DMA_GET_REQUIRED_MASK
 u64 dma_get_required_mask(struct device *dev)
 {
 	u32 low_totalram = ((max_pfn - 1) << PAGE_SHIFT);
 	u32 high_totalram = ((max_pfn - 1) >> (32 - PAGE_SHIFT));
 	u64 mask;
 	if (!high_totalram) {
 		/* convert to mask just covering totalram */
 		low_totalram = (1 << (fls(low_totalram) - 1));
 		low_totalram += low_totalram - 1;
 		mask = low_totalram;

drivers/base/power/main.c

Diff comments View file @ adf0949

 /*
  * drivers/base/power/main.c - Where the driver meets power management.
  *
  * Copyright (c) 2003 Patrick Mochel
  * Copyright (c) 2003 Open Source Development Lab
  *
  * This file is released under the GPLv2
  *
  *
  * The driver model core calls device_pm_add() when a device is registered.
  * This will intialize the embedded device_pm_info object in the device
  * and add it to the list of power-controlled devices. sysfs entries for
  * controlling device power management will also be added.
  *
  * A separate list is used for keeping track of power info, because the power
  * domain dependencies may differ from the ancestral dependencies that the
  * subsystem list maintains.
  */
 #include <linux/device.h>
 #include <linux/kallsyms.h>
 #include <linux/mutex.h>
 #include <linux/pm.h>
 #include <linux/resume-trace.h>
 #include <linux/rwsem.h>
 #include "../base.h"
 #include "power.h"
 /*
  * The entries in the dpm_list list are in a depth first order, simply
  * because children are guaranteed to be discovered after parents, and
  * are inserted at the back of the list on discovery.
  *
  * Since device_pm_add() may be called with a device semaphore held,
  * we must never try to acquire a device semaphore while holding
  * dpm_list_mutex.
  */
 LIST_HEAD(dpm_list);
 static DEFINE_MUTEX(dpm_list_mtx);
 /*
  * Set once the preparation of devices for a PM transition has started, reset
  * before starting to resume devices.  Protected by dpm_list_mtx.
  */
 static bool transition_started;
 /**
  *	device_pm_lock - lock the list of active devices used by the PM core
  */
 void device_pm_lock(void)
 {
 	mutex_lock(&dpm_list_mtx);
 }
 /**
  *	device_pm_unlock - unlock the list of active devices used by the PM core
  */
 void device_pm_unlock(void)
 {
 	mutex_unlock(&dpm_list_mtx);
 }
 /**
  *	device_pm_add - add a device to the list of active devices
  *	@dev:	Device to be added to the list
  */
 void device_pm_add(struct device *dev)
 {
 	pr_debug("PM: Adding info for %s:%s\n",
 		 dev->bus ? dev->bus->name : "No Bus",
 		 kobject_name(&dev->kobj));
 	mutex_lock(&dpm_list_mtx);
 	if (dev->parent) {
 		if (dev->parent->power.status >= DPM_SUSPENDING)
 			dev_warn(dev, "parent %s should not be sleeping\n",
 				dev->parent->bus_id);
 	} else if (transition_started) {
 		/*
 		 * We refuse to register parentless devices while a PM
 		 * transition is in progress in order to avoid leaving them
 		 * unhandled down the road
 		 */
 		dev_WARN(dev, "Parentless device registered during a PM transaction\n");
 	}
 	list_add_tail(&dev->power.entry, &dpm_list);
 	mutex_unlock(&dpm_list_mtx);
 }
 /**
  *	device_pm_remove - remove a device from the list of active devices
  *	@dev:	Device to be removed from the list
  *
  *	This function also removes the device's PM-related sysfs attributes.
  */
 void device_pm_remove(struct device *dev)
 {
 	pr_debug("PM: Removing info for %s:%s\n",
 		 dev->bus ? dev->bus->name : "No Bus",
 		 kobject_name(&dev->kobj));
 	mutex_lock(&dpm_list_mtx);
 	list_del_init(&dev->power.entry);
 	mutex_unlock(&dpm_list_mtx);
 }
 /**
  *	pm_op - execute the PM operation appropiate for given PM event
  *	@dev:	Device.
  *	@ops:	PM operations to choose from.
  *	@state:	PM transition of the system being carried out.
  */
-static int pm_op(struct device *dev, struct pm_ops *ops, pm_message_t state)
+static int pm_op(struct device *dev, struct dev_pm_ops *ops,
+			pm_message_t state)
 {
 	int error = 0;
 	switch (state.event) {
 #ifdef CONFIG_SUSPEND
 	case PM_EVENT_SUSPEND:
 		if (ops->suspend) {
 			error = ops->suspend(dev);
 			suspend_report_result(ops->suspend, error);
 		}
 		break;
 	case PM_EVENT_RESUME:
 		if (ops->resume) {
 			error = ops->resume(dev);
 			suspend_report_result(ops->resume, error);
 		}
 		break;
 #endif /* CONFIG_SUSPEND */
 #ifdef CONFIG_HIBERNATION
 	case PM_EVENT_FREEZE:
 	case PM_EVENT_QUIESCE:
 		if (ops->freeze) {
 			error = ops->freeze(dev);
 			suspend_report_result(ops->freeze, error);
 		}
 		break;
 	case PM_EVENT_HIBERNATE:
 		if (ops->poweroff) {
 			error = ops->poweroff(dev);
 			suspend_report_result(ops->poweroff, error);
 		}
 		break;
 	case PM_EVENT_THAW:
 	case PM_EVENT_RECOVER:
 		if (ops->thaw) {
 			error = ops->thaw(dev);
 			suspend_report_result(ops->thaw, error);
 		}
 		break;
 	case PM_EVENT_RESTORE:
 		if (ops->restore) {
 			error = ops->restore(dev);
 			suspend_report_result(ops->restore, error);
 		}
 		break;
 #endif /* CONFIG_HIBERNATION */
 	default:
 		error = -EINVAL;
 	}
 	return error;
 }
 /**
  *	pm_noirq_op - execute the PM operation appropiate for given PM event
  *	@dev:	Device.
  *	@ops:	PM operations to choose from.
  *	@state: PM transition of the system being carried out.
  *
  *	The operation is executed with interrupts disabled by the only remaining
  *	functional CPU in the system.
  */
-static int pm_noirq_op(struct device *dev, struct pm_ext_ops *ops,
+static int pm_noirq_op(struct device *dev, struct dev_pm_ops *ops,
 			pm_message_t state)
 {
 	int error = 0;
 	switch (state.event) {
 #ifdef CONFIG_SUSPEND
 	case PM_EVENT_SUSPEND:
 		if (ops->suspend_noirq) {
 			error = ops->suspend_noirq(dev);
 			suspend_report_result(ops->suspend_noirq, error);
 		}
 		break;
 	case PM_EVENT_RESUME:
 		if (ops->resume_noirq) {
 			error = ops->resume_noirq(dev);
 			suspend_report_result(ops->resume_noirq, error);
 		}
 		break;
 #endif /* CONFIG_SUSPEND */
 #ifdef CONFIG_HIBERNATION
 	case PM_EVENT_FREEZE:
 	case PM_EVENT_QUIESCE:
 		if (ops->freeze_noirq) {
 			error = ops->freeze_noirq(dev);
 			suspend_report_result(ops->freeze_noirq, error);
 		}
 		break;
 	case PM_EVENT_HIBERNATE:
 		if (ops->poweroff_noirq) {
 			error = ops->poweroff_noirq(dev);
 			suspend_report_result(ops->poweroff_noirq, error);
 		}
 		break;
 	case PM_EVENT_THAW:
 	case PM_EVENT_RECOVER:
 		if (ops->thaw_noirq) {
 			error = ops->thaw_noirq(dev);
 			suspend_report_result(ops->thaw_noirq, error);
 		}
 		break;
 	case PM_EVENT_RESTORE:
 		if (ops->restore_noirq) {
 			error = ops->restore_noirq(dev);
 			suspend_report_result(ops->restore_noirq, error);
 		}
 		break;
 #endif /* CONFIG_HIBERNATION */
 	default:
 		error = -EINVAL;
 	}
 	return error;
 }
 static char *pm_verb(int event)
 {
 	switch (event) {
 	case PM_EVENT_SUSPEND:
 		return "suspend";
 	case PM_EVENT_RESUME:
 		return "resume";
 	case PM_EVENT_FREEZE:
 		return "freeze";
 	case PM_EVENT_QUIESCE:
 		return "quiesce";
 	case PM_EVENT_HIBERNATE:
 		return "hibernate";
 	case PM_EVENT_THAW:
 		return "thaw";
 	case PM_EVENT_RESTORE:
 		return "restore";
 	case PM_EVENT_RECOVER:
 		return "recover";
 	default:
 		return "(unknown PM event)";
 	}
 }
 static void pm_dev_dbg(struct device *dev, pm_message_t state, char *info)
 {
 	dev_dbg(dev, "%s%s%s\n", info, pm_verb(state.event),
 		((state.event & PM_EVENT_SLEEP) && device_may_wakeup(dev)) ?
 		", may wakeup" : "");
 }
 static void pm_dev_err(struct device *dev, pm_message_t state, char *info,
 			int error)
 {
 	printk(KERN_ERR "PM: Device %s failed to %s%s: error %d\n",
 		kobject_name(&dev->kobj), pm_verb(state.event), info, error);
 }
 /*------------------------- Resume routines -------------------------*/
 /**
  *	resume_device_noirq - Power on one device (early resume).
  *	@dev:	Device.
  *	@state: PM transition of the system being carried out.
  *
  *	Must be called with interrupts disabled.
  */
 static int resume_device_noirq(struct device *dev, pm_message_t state)
 {
 	int error = 0;
 	TRACE_DEVICE(dev);
 	TRACE_RESUME(0);
 	if (!dev->bus)
 		goto End;
 	if (dev->bus->pm) {
 		pm_dev_dbg(dev, state, "EARLY ");
 		error = pm_noirq_op(dev, dev->bus->pm, state);
 	} else if (dev->bus->resume_early) {
 		pm_dev_dbg(dev, state, "legacy EARLY ");
 		error = dev->bus->resume_early(dev);
 	}
  End:
 	TRACE_RESUME(error);
 	return error;
 }
 /**
  *	dpm_power_up - Power on all regular (non-sysdev) devices.
  *	@state: PM transition of the system being carried out.
  *
  *	Execute the appropriate "noirq resume" callback for all devices marked
  *	as DPM_OFF_IRQ.
  *
  *	Must be called with interrupts disabled and only one CPU running.
  */
 static void dpm_power_up(pm_message_t state)
 {
 	struct device *dev;
 	list_for_each_entry(dev, &dpm_list, power.entry)
 		if (dev->power.status > DPM_OFF) {
 			int error;
 			dev->power.status = DPM_OFF;
 			error = resume_device_noirq(dev, state);
 			if (error)
 				pm_dev_err(dev, state, " early", error);
 		}
 }
 /**
  *	device_power_up - Turn on all devices that need special attention.
  *	@state: PM transition of the system being carried out.
  *
  *	Power on system devices, then devices that required we shut them down
  *	with interrupts disabled.
  *
  *	Must be called with interrupts disabled.
  */
 void device_power_up(pm_message_t state)
 {
 	sysdev_resume();
 	dpm_power_up(state);
 }
 EXPORT_SYMBOL_GPL(device_power_up);
 /**
  *	resume_device - Restore state for one device.
  *	@dev:	Device.
  *	@state: PM transition of the system being carried out.
  */
 static int resume_device(struct device *dev, pm_message_t state)
 {
 	int error = 0;
 	TRACE_DEVICE(dev);
 	TRACE_RESUME(0);
 	down(&dev->sem);
 	if (dev->bus) {
 		if (dev->bus->pm) {
 			pm_dev_dbg(dev, state, "");
-			error = pm_op(dev, &dev->bus->pm->base, state);
+			error = pm_op(dev, dev->bus->pm, state);
 		} else if (dev->bus->resume) {
 			pm_dev_dbg(dev, state, "legacy ");
 			error = dev->bus->resume(dev);
 		}
 		if (error)
 			goto End;
 	}
 	if (dev->type) {
 		if (dev->type->pm) {
 			pm_dev_dbg(dev, state, "type ");
 			error = pm_op(dev, dev->type->pm, state);
 		} else if (dev->type->resume) {
 			pm_dev_dbg(dev, state, "legacy type ");
 			error = dev->type->resume(dev);
 		}
 		if (error)
 			goto End;
 	}
 	if (dev->class) {
 		if (dev->class->pm) {
 			pm_dev_dbg(dev, state, "class ");
 			error = pm_op(dev, dev->class->pm, state);
 		} else if (dev->class->resume) {
 			pm_dev_dbg(dev, state, "legacy class ");
 			error = dev->class->resume(dev);
 		}
 	}
  End:
 	up(&dev->sem);
 	TRACE_RESUME(error);
 	return error;
 }
 /**
  *	dpm_resume - Resume every device.
  *	@state: PM transition of the system being carried out.
  *
  *	Execute the appropriate "resume" callback for all devices the status of
  *	which indicates that they are inactive.
  */
 static void dpm_resume(pm_message_t state)
 {
 	struct list_head list;
 	INIT_LIST_HEAD(&list);
 	mutex_lock(&dpm_list_mtx);
 	transition_started = false;
 	while (!list_empty(&dpm_list)) {
 		struct device *dev = to_device(dpm_list.next);
 		get_device(dev);
 		if (dev->power.status >= DPM_OFF) {
 			int error;
 			dev->power.status = DPM_RESUMING;
 			mutex_unlock(&dpm_list_mtx);
 			error = resume_device(dev, state);
 			mutex_lock(&dpm_list_mtx);
 			if (error)
 				pm_dev_err(dev, state, "", error);
 		} else if (dev->power.status == DPM_SUSPENDING) {
 			/* Allow new children of the device to be registered */
 			dev->power.status = DPM_RESUMING;
 		}
 		if (!list_empty(&dev->power.entry))
 			list_move_tail(&dev->power.entry, &list);
 		put_device(dev);
 	}
 	list_splice(&list, &dpm_list);
 	mutex_unlock(&dpm_list_mtx);
 }
 /**
  *	complete_device - Complete a PM transition for given device
  *	@dev:	Device.
  *	@state: PM transition of the system being carried out.
  */
 static void complete_device(struct device *dev, pm_message_t state)
 {
 	down(&dev->sem);
 	if (dev->class && dev->class->pm && dev->class->pm->complete) {
 		pm_dev_dbg(dev, state, "completing class ");
 		dev->class->pm->complete(dev);
 	}
 	if (dev->type && dev->type->pm && dev->type->pm->complete) {
 		pm_dev_dbg(dev, state, "completing type ");
 		dev->type->pm->complete(dev);
 	}
-	if (dev->bus && dev->bus->pm && dev->bus->pm->base.complete) {
+	if (dev->bus && dev->bus->pm && dev->bus->pm->complete) {
 		pm_dev_dbg(dev, state, "completing ");
-		dev->bus->pm->base.complete(dev);
+		dev->bus->pm->complete(dev);
 	}
 	up(&dev->sem);
 }
 /**
  *	dpm_complete - Complete a PM transition for all devices.
  *	@state: PM transition of the system being carried out.
  *
  *	Execute the ->complete() callbacks for all devices that are not marked
  *	as DPM_ON.
  */
 static void dpm_complete(pm_message_t state)
 {
 	struct list_head list;
 	INIT_LIST_HEAD(&list);
 	mutex_lock(&dpm_list_mtx);
 	while (!list_empty(&dpm_list)) {
 		struct device *dev = to_device(dpm_list.prev);
 		get_device(dev);
 		if (dev->power.status > DPM_ON) {
 			dev->power.status = DPM_ON;
 			mutex_unlock(&dpm_list_mtx);
 			complete_device(dev, state);
 			mutex_lock(&dpm_list_mtx);
 		}
 		if (!list_empty(&dev->power.entry))
 			list_move(&dev->power.entry, &list);
 		put_device(dev);
 	}
 	list_splice(&list, &dpm_list);
 	mutex_unlock(&dpm_list_mtx);
 }
 /**
  *	device_resume - Restore state of each device in system.
  *	@state: PM transition of the system being carried out.
  *
  *	Resume all the devices, unlock them all, and allow new
  *	devices to be registered once again.
  */
 void device_resume(pm_message_t state)
 {
 	might_sleep();
 	dpm_resume(state);
 	dpm_complete(state);
 }
 EXPORT_SYMBOL_GPL(device_resume);
 /*------------------------- Suspend routines -------------------------*/
 /**
  *	resume_event - return a PM message representing the resume event
  *	               corresponding to given sleep state.
  *	@sleep_state: PM message representing a sleep state.
  */
 static pm_message_t resume_event(pm_message_t sleep_state)
 {
 	switch (sleep_state.event) {
 	case PM_EVENT_SUSPEND:
 		return PMSG_RESUME;
 	case PM_EVENT_FREEZE:
 	case PM_EVENT_QUIESCE:
 		return PMSG_RECOVER;
 	case PM_EVENT_HIBERNATE:
 		return PMSG_RESTORE;
 	}
 	return PMSG_ON;
 }
 /**
  *	suspend_device_noirq - Shut down one device (late suspend).
  *	@dev:	Device.
  *	@state: PM transition of the system being carried out.
  *
  *	This is called with interrupts off and only a single CPU running.
  */
 static int suspend_device_noirq(struct device *dev, pm_message_t state)
 {
 	int error = 0;
 	if (!dev->bus)
 		return 0;
 	if (dev->bus->pm) {
 		pm_dev_dbg(dev, state, "LATE ");
 		error = pm_noirq_op(dev, dev->bus->pm, state);
 	} else if (dev->bus->suspend_late) {
 		pm_dev_dbg(dev, state, "legacy LATE ");
 		error = dev->bus->suspend_late(dev, state);
 		suspend_report_result(dev->bus->suspend_late, error);
 	}
 	return error;
 }
 /**
  *	device_power_down - Shut down special devices.
  *	@state: PM transition of the system being carried out.
  *
  *	Power down devices that require interrupts to be disabled.
  *	Then power down system devices.
  *
  *	Must be called with interrupts disabled and only one CPU running.
  */
 int device_power_down(pm_message_t state)
 {
 	struct device *dev;
 	int error = 0;
 	list_for_each_entry_reverse(dev, &dpm_list, power.entry) {
 		error = suspend_device_noirq(dev, state);
 		if (error) {
 			pm_dev_err(dev, state, " late", error);
 			break;
 		}
 		dev->power.status = DPM_OFF_IRQ;
 	}
 	if (!error)
 		error = sysdev_suspend(state);
 	if (error)
 		dpm_power_up(resume_event(state));
 	return error;
 }
 EXPORT_SYMBOL_GPL(device_power_down);
 /**
  *	suspend_device - Save state of one device.
  *	@dev:	Device.
  *	@state: PM transition of the system being carried out.
  */
 static int suspend_device(struct device *dev, pm_message_t state)
 {
 	int error = 0;
 	down(&dev->sem);
 	if (dev->class) {
 		if (dev->class->pm) {
 			pm_dev_dbg(dev, state, "class ");
 			error = pm_op(dev, dev->class->pm, state);
 		} else if (dev->class->suspend) {
 			pm_dev_dbg(dev, state, "legacy class ");
 			error = dev->class->suspend(dev, state);
 			suspend_report_result(dev->class->suspend, error);
 		}
 		if (error)
 			goto End;
 	}
 	if (dev->type) {
 		if (dev->type->pm) {
 			pm_dev_dbg(dev, state, "type ");
 			error = pm_op(dev, dev->type->pm, state);
 		} else if (dev->type->suspend) {
 			pm_dev_dbg(dev, state, "legacy type ");
 			error = dev->type->suspend(dev, state);
 			suspend_report_result(dev->type->suspend, error);
 		}
 		if (error)
 			goto End;
 	}
 	if (dev->bus) {
 		if (dev->bus->pm) {
 			pm_dev_dbg(dev, state, "");
-			error = pm_op(dev, &dev->bus->pm->base, state);
+			error = pm_op(dev, dev->bus->pm, state);
 		} else if (dev->bus->suspend) {
 			pm_dev_dbg(dev, state, "legacy ");
 			error = dev->bus->suspend(dev, state);
 			suspend_report_result(dev->bus->suspend, error);
 		}
 	}
  End:
 	up(&dev->sem);
 	return error;
 }
 /**
  *	dpm_suspend - Suspend every device.
  *	@state: PM transition of the system being carried out.
  *
  *	Execute the appropriate "suspend" callbacks for all devices.
  */
 static int dpm_suspend(pm_message_t state)
 {
 	struct list_head list;
 	int error = 0;
 	INIT_LIST_HEAD(&list);
 	mutex_lock(&dpm_list_mtx);
 	while (!list_empty(&dpm_list)) {
 		struct device *dev = to_device(dpm_list.prev);
 		get_device(dev);
 		mutex_unlock(&dpm_list_mtx);
 		error = suspend_device(dev, state);
 		mutex_lock(&dpm_list_mtx);
 		if (error) {
 			pm_dev_err(dev, state, "", error);
 			put_device(dev);
 			break;
 		}
 		dev->power.status = DPM_OFF;
 		if (!list_empty(&dev->power.entry))
 			list_move(&dev->power.entry, &list);
 		put_device(dev);
 	}
 	list_splice(&list, dpm_list.prev);
 	mutex_unlock(&dpm_list_mtx);
 	return error;
 }
 /**
  *	prepare_device - Execute the ->prepare() callback(s) for given device.
  *	@dev:	Device.
  *	@state: PM transition of the system being carried out.
  */
 static int prepare_device(struct device *dev, pm_message_t state)
 {
 	int error = 0;
 	down(&dev->sem);
-	if (dev->bus && dev->bus->pm && dev->bus->pm->base.prepare) {
+	if (dev->bus && dev->bus->pm && dev->bus->pm->prepare) {
 		pm_dev_dbg(dev, state, "preparing ");
-		error = dev->bus->pm->base.prepare(dev);
+		error = dev->bus->pm->prepare(dev);
-		suspend_report_result(dev->bus->pm->base.prepare, error);
+		suspend_report_result(dev->bus->pm->prepare, error);
 		if (error)
 			goto End;
 	}
 	if (dev->type && dev->type->pm && dev->type->pm->prepare) {
 		pm_dev_dbg(dev, state, "preparing type ");
 		error = dev->type->pm->prepare(dev);
 		suspend_report_result(dev->type->pm->prepare, error);
 		if (error)
 			goto End;
 	}
 	if (dev->class && dev->class->pm && dev->class->pm->prepare) {
 		pm_dev_dbg(dev, state, "preparing class ");
 		error = dev->class->pm->prepare(dev);
 		suspend_report_result(dev->class->pm->prepare, error);
 	}
  End:
 	up(&dev->sem);
 	return error;
 }
 /**
  *	dpm_prepare - Prepare all devices for a PM transition.
  *	@state: PM transition of the system being carried out.
  *
  *	Execute the ->prepare() callback for all devices.
  */
 static int dpm_prepare(pm_message_t state)
 {
 	struct list_head list;
 	int error = 0;
 	INIT_LIST_HEAD(&list);
 	mutex_lock(&dpm_list_mtx);
 	transition_started = true;
 	while (!list_empty(&dpm_list)) {
 		struct device *dev = to_device(dpm_list.next);
 		get_device(dev);
 		dev->power.status = DPM_PREPARING;
 		mutex_unlock(&dpm_list_mtx);
 		error = prepare_device(dev, state);
 		mutex_lock(&dpm_list_mtx);
 		if (error) {
 			dev->power.status = DPM_ON;
 			if (error == -EAGAIN) {
 				put_device(dev);
 				continue;
 			}
 			printk(KERN_ERR "PM: Failed to prepare device %s "
 				"for power transition: error %d\n",
 				kobject_name(&dev->kobj), error);
 			put_device(dev);
 			break;
 		}
 		dev->power.status = DPM_SUSPENDING;
 		if (!list_empty(&dev->power.entry))
 			list_move_tail(&dev->power.entry, &list);
 		put_device(dev);
 	}
 	list_splice(&list, &dpm_list);
 	mutex_unlock(&dpm_list_mtx);
 	return error;
 }
 /**
  *	device_suspend - Save state and stop all devices in system.
  *	@state: PM transition of the system being carried out.
  *
  *	Prepare and suspend all devices.
  */
 int device_suspend(pm_message_t state)
 {
 	int error;
 	might_sleep();
 	error = dpm_prepare(state);
 	if (!error)
 		error = dpm_suspend(state);
 	return error;
 }
 EXPORT_SYMBOL_GPL(device_suspend);
 void __suspend_report_result(const char *function, void *fn, int ret)
 {
 	if (ret)
 		printk(KERN_ERR "%s(): %pF returns %d\n", function, fn, ret);
 }
 EXPORT_SYMBOL_GPL(__suspend_report_result);

drivers/pci/pci-driver.c

Diff comments View file @ adf0949

 /*
  * drivers/pci/pci-driver.c
  *
  * (C) Copyright 2002-2004, 2007 Greg Kroah-Hartman <greg@kroah.com>
  * (C) Copyright 2007 Novell Inc.
  *
  * Released under the GPL v2 only.
  *
  */
 #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"
 /*
  * 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);
 	const struct pci_device_id *ids = pdrv->id_table;
 	__u32 vendor, device, subvendor=PCI_ANY_ID,
 		subdevice=PCI_ANY_ID, class=0, class_mask=0;
 	unsigned long driver_data=0;
 	int fields=0;
 	int retval;
 	fields = sscanf(buf, "%x %x %x %x %x %x %lx",
 			&vendor, &device, &subvendor, &subdevice,
 			&class, &class_mask, &driver_data);
 	if (fields < 2)
 		return -EINVAL;
 	/* Only accept driver_data values that match an existing id_table
 	   entry */
 	retval = -EINVAL;
 	while (ids->vendor || ids->subvendor || ids->class_mask) {
 		if (driver_data == ids->driver_data) {
 			retval = 0;
 			break;
 		}
 		ids++;
 	}
 	if (retval)	/* No match */
 		return retval;
 	dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
 	if (!dynid)
 		return -ENOMEM;
 	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 = driver_data;
 	spin_lock(&pdrv->dynids.lock);
 	list_add_tail(&dynid->node, &pdrv->dynids.list);
 	spin_unlock(&pdrv->dynids.lock);
 	if (get_driver(&pdrv->driver)) {
 		retval = driver_attach(&pdrv->driver);
 		put_driver(&pdrv->driver);
 	}
 	if (retval)
 		return retval;
 	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 = driver_create_file(&drv->driver, &driver_attr_new_id);
 	return error;
 }
 static void pci_remove_newid_file(struct pci_driver *drv)
 {
 	driver_remove_file(&drv->driver, &driver_attr_new_id);
 }
 #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;
 }
 static inline void pci_remove_newid_file(struct pci_driver *drv) {}
 #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.
  *
  * Deprecated, 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
  * @drv: the PCI driver to match against
  * @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.
  */
 static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
 						    struct pci_dev *dev)
 {
 	struct pci_dynid *dynid;
 	/* Look at the dynamic ids first, before the static 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 pci_match_id(drv->id_table, dev);
 }
 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 = dev_to_node(&dev->dev);
 	if (node >= 0) {
 		node_to_cpumask_ptr(nodecpumask, node);
 		set_cpus_allowed_ptr(current, nodecpumask);
 	}
 	/* And set default memory allocation policy */
 	oldpol = current->mempolicy;
 	current->mempolicy = NULL;	/* fall back to system default policy */
 #endif
 	error = drv->probe(dev, id);
 #ifdef CONFIG_NUMA
 	set_cpus_allowed_ptr(current, &oldmask);
 	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;
 	}
 	/*
 	 * If the device is still on, set the power state as "unknown",
 	 * since it might change by the next time we load the driver.
 	 */
 	if (pci_dev->current_state == PCI_D0)
 		pci_dev->current_state = PCI_UNKNOWN;
 	/*
 	 * 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 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);
 	pci_msi_shutdown(pci_dev);
 	pci_msix_shutdown(pci_dev);
 }
 #ifdef CONFIG_PM_SLEEP
 /*
  * Default "suspend" method for devices that have no driver provided suspend,
  * or not even a driver at all.
  */
 static void pci_default_pm_suspend(struct pci_dev *pci_dev)
 {
 	pci_save_state(pci_dev);
 	/*
 	 * mark its power state as "unknown", since we don't know if
 	 * e.g. the BIOS will change its device state when we suspend.
 	 */
 	if (pci_dev->current_state == PCI_D0)
 		pci_dev->current_state = PCI_UNKNOWN;
 }
 /*
  * Default "resume" method for devices that have no driver provided resume,
  * or not even a driver at all.
  */
 static int pci_default_pm_resume(struct pci_dev *pci_dev)
 {
 	int retval = 0;
 	/* restore the PCI config space */
 	pci_restore_state(pci_dev);
 	/* if the device was enabled before suspend, reenable */
 	retval = pci_reenable_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);
 	return retval;
 }
 static int pci_legacy_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_default_pm_suspend(pci_dev);
 	}
 	return i;
 }
 static int pci_legacy_suspend_late(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_late) {
 		i = drv->suspend_late(pci_dev, state);
 		suspend_report_result(drv->suspend_late, i);
 	}
 	return i;
 }
 static int pci_legacy_resume(struct device *dev)
 {
 	int error;
 	struct pci_dev * pci_dev = to_pci_dev(dev);
 	struct pci_driver * drv = pci_dev->driver;
 	if (drv && drv->resume)
 		error = drv->resume(pci_dev);
 	else
 		error = pci_default_pm_resume(pci_dev);
 	return error;
 }
 static int pci_legacy_resume_early(struct device *dev)
 {
 	int error = 0;
 	struct pci_dev * pci_dev = to_pci_dev(dev);
 	struct pci_driver * drv = pci_dev->driver;
 	if (drv && drv->resume_early)
 		error = drv->resume_early(pci_dev);
 	return error;
 }
 static int pci_pm_prepare(struct device *dev)
 {
 	struct device_driver *drv = dev->driver;
 	int error = 0;
 	if (drv && drv->pm && drv->pm->prepare)
 		error = drv->pm->prepare(dev);
 	return error;
 }
 static void pci_pm_complete(struct device *dev)
 {
 	struct device_driver *drv = dev->driver;
 	if (drv && drv->pm && drv->pm->complete)
 		drv->pm->complete(dev);
 }
 #ifdef CONFIG_SUSPEND
 static int pci_pm_suspend(struct device *dev)
 {
 	struct pci_dev *pci_dev = to_pci_dev(dev);
 	struct device_driver *drv = dev->driver;
 	int error = 0;
 	if (drv && drv->pm) {
 		if (drv->pm->suspend) {
 			error = drv->pm->suspend(dev);
 			suspend_report_result(drv->pm->suspend, error);
 		} else {
 			pci_default_pm_suspend(pci_dev);
 		}
 	} else {
 		error = pci_legacy_suspend(dev, PMSG_SUSPEND);
 	}
 	pci_fixup_device(pci_fixup_suspend, pci_dev);
 	return error;
 }
 static int pci_pm_suspend_noirq(struct device *dev)
 {
-	struct pci_dev *pci_dev = to_pci_dev(dev);
+	struct device_driver *drv = dev->driver;
-	struct pci_driver *drv = pci_dev->driver;
 	int error = 0;
 	if (drv && drv->pm) {
 		if (drv->pm->suspend_noirq) {
 			error = drv->pm->suspend_noirq(dev);
 			suspend_report_result(drv->pm->suspend_noirq, error);
 		}
 	} else {
 		error = pci_legacy_suspend_late(dev, PMSG_SUSPEND);
 	}
 	return error;
 }
 static int pci_pm_resume(struct device *dev)
 {
 	struct pci_dev *pci_dev = to_pci_dev(dev);
 	struct device_driver *drv = dev->driver;
 	int error;
 	pci_fixup_device(pci_fixup_resume, pci_dev);
 	if (drv && drv->pm) {
 		error = drv->pm->resume ? drv->pm->resume(dev) :
 			pci_default_pm_resume(pci_dev);
 	} else {
 		error = pci_legacy_resume(dev);
 	}
 	return error;
 }
 static int pci_pm_resume_noirq(struct device *dev)
 {
-	struct pci_dev *pci_dev = to_pci_dev(dev);
+	struct device_driver *drv = dev->driver;
-	struct pci_driver *drv = pci_dev->driver;
 	int error = 0;
-	pci_fixup_device(pci_fixup_resume_early, pci_dev);
+	pci_fixup_device(pci_fixup_resume_early, to_pci_dev(dev));
 	if (drv && drv->pm) {
 		if (drv->pm->resume_noirq)
 			error = drv->pm->resume_noirq(dev);
 	} else {
 		error = pci_legacy_resume_early(dev);
 	}
 	return error;
 }
 #else /* !CONFIG_SUSPEND */
 #define pci_pm_suspend		NULL
 #define pci_pm_suspend_noirq	NULL
 #define pci_pm_resume		NULL
 #define pci_pm_resume_noirq	NULL
 #endif /* !CONFIG_SUSPEND */
 #ifdef CONFIG_HIBERNATION
 static int pci_pm_freeze(struct device *dev)
 {
 	struct pci_dev *pci_dev = to_pci_dev(dev);
 	struct device_driver *drv = dev->driver;
 	int error = 0;
 	if (drv && drv->pm) {
 		if (drv->pm->freeze) {
 			error = drv->pm->freeze(dev);
 			suspend_report_result(drv->pm->freeze, error);
 		} else {
 			pci_default_pm_suspend(pci_dev);
 		}
 	} else {
 		error = pci_legacy_suspend(dev, PMSG_FREEZE);
 		pci_fixup_device(pci_fixup_suspend, pci_dev);
 	}
 	return error;
 }
 static int pci_pm_freeze_noirq(struct device *dev)
 {
-	struct pci_dev *pci_dev = to_pci_dev(dev);
+	struct device_driver *drv = dev->driver;
-	struct pci_driver *drv = pci_dev->driver;
 	int error = 0;
 	if (drv && drv->pm) {
 		if (drv->pm->freeze_noirq) {
 			error = drv->pm->freeze_noirq(dev);
 			suspend_report_result(drv->pm->freeze_noirq, error);
 		}
 	} else {
 		error = pci_legacy_suspend_late(dev, PMSG_FREEZE);
 	}
 	return error;
 }
 static int pci_pm_thaw(struct device *dev)
 {
 	struct device_driver *drv = dev->driver;
 	int error = 0;
 	if (drv && drv->pm) {
 		if (drv->pm->thaw)
 			error =  drv->pm->thaw(dev);
 	} else {
 		pci_fixup_device(pci_fixup_resume, to_pci_dev(dev));
 		error = pci_legacy_resume(dev);
 	}
 	return error;
 }
 static int pci_pm_thaw_noirq(struct device *dev)
 {
-	struct pci_dev *pci_dev = to_pci_dev(dev);
+	struct device_driver *drv = dev->driver;
-	struct pci_driver *drv = pci_dev->driver;
 	int error = 0;
 	if (drv && drv->pm) {
 		if (drv->pm->thaw_noirq)
 			error = drv->pm->thaw_noirq(dev);
 	} else {
-		pci_fixup_device(pci_fixup_resume_early, pci_dev);
+		pci_fixup_device(pci_fixup_resume_early, to_pci_dev(dev));
 		error = pci_legacy_resume_early(dev);
 	}
 	return error;
 }
 static int pci_pm_poweroff(struct device *dev)
 {
 	struct device_driver *drv = dev->driver;
 	int error = 0;
 	pci_fixup_device(pci_fixup_suspend, to_pci_dev(dev));
 	if (drv && drv->pm) {
 		if (drv->pm->poweroff) {
 			error = drv->pm->poweroff(dev);
 			suspend_report_result(drv->pm->poweroff, error);
 		}
 	} else {
 		error = pci_legacy_suspend(dev, PMSG_HIBERNATE);
 	}
 	return error;
 }
 static int pci_pm_poweroff_noirq(struct device *dev)
 {
-	struct pci_dev *pci_dev = to_pci_dev(dev);
+	struct device_driver *drv = dev->driver;
-	struct pci_driver *drv = pci_dev->driver;
 	int error = 0;
 	if (drv && drv->pm) {
 		if (drv->pm->poweroff_noirq) {
 			error = drv->pm->poweroff_noirq(dev);
 			suspend_report_result(drv->pm->poweroff_noirq, error);
 		}
 	} else {
 		error = pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
 	}
 	return error;
 }
 static int pci_pm_restore(struct device *dev)
 {
 	struct pci_dev *pci_dev = to_pci_dev(dev);
 	struct device_driver *drv = dev->driver;
 	int error;
 	if (drv && drv->pm) {
 		error = drv->pm->restore ? drv->pm->restore(dev) :
 			pci_default_pm_resume(pci_dev);
 	} else {
 		error = pci_legacy_resume(dev);
 	}
 	pci_fixup_device(pci_fixup_resume, pci_dev);
 	return error;
 }
 static int pci_pm_restore_noirq(struct device *dev)
 {
 	struct pci_dev *pci_dev = to_pci_dev(dev);
-	struct pci_driver *drv = pci_dev->driver;
+	struct device_driver *drv = dev->driver;
 	int error = 0;
 	pci_fixup_device(pci_fixup_resume, pci_dev);
 	if (drv && drv->pm) {
 		if (drv->pm->restore_noirq)
 			error = drv->pm->restore_noirq(dev);
 	} else {
 		error = pci_legacy_resume_early(dev);
 	}
 	pci_fixup_device(pci_fixup_resume_early, pci_dev);
 	return error;
 }
 #else /* !CONFIG_HIBERNATION */
 #define pci_pm_freeze		NULL
 #define pci_pm_freeze_noirq	NULL
 #define pci_pm_thaw		NULL
 #define pci_pm_thaw_noirq	NULL
 #define pci_pm_poweroff		NULL
 #define pci_pm_poweroff_noirq	NULL
 #define pci_pm_restore		NULL
 #define pci_pm_restore_noirq	NULL
 #endif /* !CONFIG_HIBERNATION */
-struct pm_ext_ops pci_pm_ops = {
+struct dev_pm_ops pci_dev_pm_ops = {
-	.base = {
+	.prepare = pci_pm_prepare,
-		.prepare = pci_pm_prepare,
+	.complete = pci_pm_complete,
-		.complete = pci_pm_complete,
+	.suspend = pci_pm_suspend,
-		.suspend = pci_pm_suspend,
+	.resume = pci_pm_resume,
-		.resume = pci_pm_resume,
+	.freeze = pci_pm_freeze,
-		.freeze = pci_pm_freeze,
+	.thaw = pci_pm_thaw,
-		.thaw = pci_pm_thaw,
+	.poweroff = pci_pm_poweroff,
-		.poweroff = pci_pm_poweroff,
+	.restore = pci_pm_restore,
-		.restore = pci_pm_restore,
-	},
 	.suspend_noirq = pci_pm_suspend_noirq,
 	.resume_noirq = pci_pm_resume_noirq,
 	.freeze_noirq = pci_pm_freeze_noirq,
 	.thaw_noirq = pci_pm_thaw_noirq,
 	.poweroff_noirq = pci_pm_poweroff_noirq,
 	.restore_noirq = pci_pm_restore_noirq,
 };
-#define PCI_PM_OPS_PTR	&pci_pm_ops
+#define PCI_PM_OPS_PTR	(&pci_dev_pm_ops)
 #else /* !CONFIG_PM_SLEEP */
 #define PCI_PM_OPS_PTR	NULL
 #endif /* !CONFIG_PM_SLEEP */
 /**
  * __pci_register_driver - register a new pci driver
  * @drv: the driver structure to register
  * @owner: owner module of drv
  * @mod_name: module name string
  *
  * 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,
 			  const char *mod_name)
 {
 	int error;
 	/* initialize common driver fields */
 	drv->driver.name = drv->name;
 	drv->driver.bus = &pci_bus_type;
 	drv->driver.owner = owner;
 	drv->driver.mod_name = mod_name;
-	if (drv->pm)
-		drv->driver.pm = &drv->pm->base;
 	spin_lock_init(&drv->dynids.lock);
 	INIT_LIST_HEAD(&drv->dynids.list);
 	/* register with core */
 	error = driver_register(&drv->driver);
 	if (error)
 		return error;
 	error = pci_create_newid_file(drv);
 	if (error)
 		driver_unregister(&drv->driver);
 	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)
 {
 	pci_remove_newid_file(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, struct kobj_uevent_env *env)
 {
 	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,
 	.shutdown	= pci_device_shutdown,
 	.dev_attrs	= pci_dev_attrs,
 	.pm		= PCI_PM_OPS_PTR,
 };
 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_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);

drivers/usb/core/usb.c

Diff comments View file @ adf0949

1	/*	1	/*
2	* drivers/usb/core/usb.c	2	* drivers/usb/core/usb.c
3	*	3	*
4	* (C) Copyright Linus Torvalds 1999	4	* (C) Copyright Linus Torvalds 1999
5	* (C) Copyright Johannes Erdfelt 1999-2001	5	* (C) Copyright Johannes Erdfelt 1999-2001
6	* (C) Copyright Andreas Gal 1999	6	* (C) Copyright Andreas Gal 1999
7	* (C) Copyright Gregory P. Smith 1999	7	* (C) Copyright Gregory P. Smith 1999
8	* (C) Copyright Deti Fliegl 1999 (new USB architecture)	8	* (C) Copyright Deti Fliegl 1999 (new USB architecture)
9	* (C) Copyright Randy Dunlap 2000	9	* (C) Copyright Randy Dunlap 2000
10	* (C) Copyright David Brownell 2000-2004	10	* (C) Copyright David Brownell 2000-2004
11	* (C) Copyright Yggdrasil Computing, Inc. 2000	11	* (C) Copyright Yggdrasil Computing, Inc. 2000
12	* (usb_device_id matching changes by Adam J. Richter)	12	* (usb_device_id matching changes by Adam J. Richter)
13	* (C) Copyright Greg Kroah-Hartman 2002-2003	13	* (C) Copyright Greg Kroah-Hartman 2002-2003
14	*	14	*
15	* NOTE! This is not actually a driver at all, rather this is	15	* NOTE! This is not actually a driver at all, rather this is
16	* just a collection of helper routines that implement the	16	* just a collection of helper routines that implement the
17	* generic USB things that the real drivers can use..	17	* generic USB things that the real drivers can use..
18	*	18	*
19	* Think of this as a "USB library" rather than anything else.	19	* Think of this as a "USB library" rather than anything else.
20	* It should be considered a slave, with no callbacks. Callbacks	20	* It should be considered a slave, with no callbacks. Callbacks
21	* are evil.	21	* are evil.
22	*/	22	*/
23		23
24	#include <linux/module.h>	24	#include <linux/module.h>
25	#include <linux/moduleparam.h>	25	#include <linux/moduleparam.h>
26	#include <linux/string.h>	26	#include <linux/string.h>
27	#include <linux/bitops.h>	27	#include <linux/bitops.h>
28	#include <linux/slab.h>	28	#include <linux/slab.h>
29	#include <linux/interrupt.h> /* for in_interrupt() */	29	#include <linux/interrupt.h> /* for in_interrupt() */
30	#include <linux/kmod.h>	30	#include <linux/kmod.h>
31	#include <linux/init.h>	31	#include <linux/init.h>
32	#include <linux/spinlock.h>	32	#include <linux/spinlock.h>
33	#include <linux/errno.h>	33	#include <linux/errno.h>
34	#include <linux/usb.h>	34	#include <linux/usb.h>
35	#include <linux/mutex.h>	35	#include <linux/mutex.h>
36	#include <linux/workqueue.h>	36	#include <linux/workqueue.h>
37		37
38	#include <asm/io.h>	38	#include <asm/io.h>
39	#include <linux/scatterlist.h>	39	#include <linux/scatterlist.h>
40	#include <linux/mm.h>	40	#include <linux/mm.h>
41	#include <linux/dma-mapping.h>	41	#include <linux/dma-mapping.h>
42		42
43	#include "hcd.h"	43	#include "hcd.h"
44	#include "usb.h"	44	#include "usb.h"
45		45
46		46
47	const char *usbcore_name = "usbcore";	47	const char *usbcore_name = "usbcore";
48		48
49	static int nousb; /* Disable USB when built into kernel image */	49	static int nousb; /* Disable USB when built into kernel image */
50		50
51	/* Workqueue for autosuspend and for remote wakeup of root hubs */	51	/* Workqueue for autosuspend and for remote wakeup of root hubs */
52	struct workqueue_struct *ksuspend_usb_wq;	52	struct workqueue_struct *ksuspend_usb_wq;
53		53
54	#ifdef CONFIG_USB_SUSPEND	54	#ifdef CONFIG_USB_SUSPEND
55	static int usb_autosuspend_delay = 2; /* Default delay value,	55	static int usb_autosuspend_delay = 2; /* Default delay value,
56	* in seconds */	56	* in seconds */
57	module_param_named(autosuspend, usb_autosuspend_delay, int, 0644);	57	module_param_named(autosuspend, usb_autosuspend_delay, int, 0644);
58	MODULE_PARM_DESC(autosuspend, "default autosuspend delay");	58	MODULE_PARM_DESC(autosuspend, "default autosuspend delay");
59		59
60	#else	60	#else
61	#define usb_autosuspend_delay 0	61	#define usb_autosuspend_delay 0
62	#endif	62	#endif
63		63
64		64
65	/**	65	/**
66	* usb_ifnum_to_if - get the interface object with a given interface number	66	* usb_ifnum_to_if - get the interface object with a given interface number
67	* @dev: the device whose current configuration is considered	67	* @dev: the device whose current configuration is considered
68	* @ifnum: the desired interface	68	* @ifnum: the desired interface
69	*	69	*
70	* This walks the device descriptor for the currently active configuration	70	* This walks the device descriptor for the currently active configuration
71	* and returns a pointer to the interface with that particular interface	71	* and returns a pointer to the interface with that particular interface
72	* number, or null.	72	* number, or null.
73	*	73	*
74	* Note that configuration descriptors are not required to assign interface	74	* Note that configuration descriptors are not required to assign interface
75	* numbers sequentially, so that it would be incorrect to assume that	75	* numbers sequentially, so that it would be incorrect to assume that
76	* the first interface in that descriptor corresponds to interface zero.	76	* the first interface in that descriptor corresponds to interface zero.
77	* This routine helps device drivers avoid such mistakes.	77	* This routine helps device drivers avoid such mistakes.
78	* However, you should make sure that you do the right thing with any	78	* However, you should make sure that you do the right thing with any
79	* alternate settings available for this interfaces.	79	* alternate settings available for this interfaces.
80	*	80	*
81	* Don't call this function unless you are bound to one of the interfaces	81	* Don't call this function unless you are bound to one of the interfaces
82	* on this device or you have locked the device!	82	* on this device or you have locked the device!
83	*/	83	*/
84	struct usb_interface usb_ifnum_to_if(const struct usb_device dev,	84	struct usb_interface usb_ifnum_to_if(const struct usb_device dev,
85	unsigned ifnum)	85	unsigned ifnum)
86	{	86	{
87	struct usb_host_config *config = dev->actconfig;	87	struct usb_host_config *config = dev->actconfig;
88	int i;	88	int i;
89		89
90	if (!config)	90	if (!config)
91	return NULL;	91	return NULL;
92	for (i = 0; i < config->desc.bNumInterfaces; i++)	92	for (i = 0; i < config->desc.bNumInterfaces; i++)
93	if (config->interface[i]->altsetting[0]	93	if (config->interface[i]->altsetting[0]
94	.desc.bInterfaceNumber == ifnum)	94	.desc.bInterfaceNumber == ifnum)
95	return config->interface[i];	95	return config->interface[i];
96		96
97	return NULL;	97	return NULL;
98	}	98	}
99	EXPORT_SYMBOL_GPL(usb_ifnum_to_if);	99	EXPORT_SYMBOL_GPL(usb_ifnum_to_if);
100		100
101	/**	101	/**
102	* usb_altnum_to_altsetting - get the altsetting structure with a given alternate setting number.	102	* usb_altnum_to_altsetting - get the altsetting structure with a given alternate setting number.
103	* @intf: the interface containing the altsetting in question	103	* @intf: the interface containing the altsetting in question
104	* @altnum: the desired alternate setting number	104	* @altnum: the desired alternate setting number
105	*	105	*
106	* This searches the altsetting array of the specified interface for	106	* This searches the altsetting array of the specified interface for
107	* an entry with the correct bAlternateSetting value and returns a pointer	107	* an entry with the correct bAlternateSetting value and returns a pointer
108	* to that entry, or null.	108	* to that entry, or null.
109	*	109	*
110	* Note that altsettings need not be stored sequentially by number, so	110	* Note that altsettings need not be stored sequentially by number, so
111	* it would be incorrect to assume that the first altsetting entry in	111	* it would be incorrect to assume that the first altsetting entry in
112	* the array corresponds to altsetting zero. This routine helps device	112	* the array corresponds to altsetting zero. This routine helps device
113	* drivers avoid such mistakes.	113	* drivers avoid such mistakes.
114	*	114	*
115	* Don't call this function unless you are bound to the intf interface	115	* Don't call this function unless you are bound to the intf interface
116	* or you have locked the device!	116	* or you have locked the device!
117	*/	117	*/
118	struct usb_host_interface *usb_altnum_to_altsetting(	118	struct usb_host_interface *usb_altnum_to_altsetting(
119	const struct usb_interface *intf,	119	const struct usb_interface *intf,
120	unsigned int altnum)	120	unsigned int altnum)
121	{	121	{
122	int i;	122	int i;
123		123
124	for (i = 0; i < intf->num_altsetting; i++) {	124	for (i = 0; i < intf->num_altsetting; i++) {
125	if (intf->altsetting[i].desc.bAlternateSetting == altnum)	125	if (intf->altsetting[i].desc.bAlternateSetting == altnum)
126	return &intf->altsetting[i];	126	return &intf->altsetting[i];
127	}	127	}
128	return NULL;	128	return NULL;
129	}	129	}
130	EXPORT_SYMBOL_GPL(usb_altnum_to_altsetting);	130	EXPORT_SYMBOL_GPL(usb_altnum_to_altsetting);
131		131
132	struct find_interface_arg {	132	struct find_interface_arg {
133	int minor;	133	int minor;
134	struct usb_interface *interface;	134	struct usb_interface *interface;
135	};	135	};
136		136
137	static int __find_interface(struct device dev, void data)	137	static int __find_interface(struct device dev, void data)
138	{	138	{
139	struct find_interface_arg *arg = data;	139	struct find_interface_arg *arg = data;
140	struct usb_interface *intf;	140	struct usb_interface *intf;
141		141
142	/* can't look at usb devices, only interfaces */	142	/* can't look at usb devices, only interfaces */
143	if (is_usb_device(dev))	143	if (is_usb_device(dev))
144	return 0;	144	return 0;
145		145
146	intf = to_usb_interface(dev);	146	intf = to_usb_interface(dev);
147	if (intf->minor != -1 && intf->minor == arg->minor) {	147	if (intf->minor != -1 && intf->minor == arg->minor) {
148	arg->interface = intf;	148	arg->interface = intf;
149	return 1;	149	return 1;
150	}	150	}
151	return 0;	151	return 0;
152	}	152	}
153		153
154	/**	154	/**
155	* usb_find_interface - find usb_interface pointer for driver and device	155	* usb_find_interface - find usb_interface pointer for driver and device
156	* @drv: the driver whose current configuration is considered	156	* @drv: the driver whose current configuration is considered
157	* @minor: the minor number of the desired device	157	* @minor: the minor number of the desired device
158	*	158	*
159	* This walks the driver device list and returns a pointer to the interface	159	* This walks the driver device list and returns a pointer to the interface
160	* with the matching minor. Note, this only works for devices that share the	160	* with the matching minor. Note, this only works for devices that share the
161	* USB major number.	161	* USB major number.
162	*/	162	*/
163	struct usb_interface usb_find_interface(struct usb_driver drv, int minor)	163	struct usb_interface usb_find_interface(struct usb_driver drv, int minor)
164	{	164	{
165	struct find_interface_arg argb;	165	struct find_interface_arg argb;
166	int retval;	166	int retval;
167		167
168	argb.minor = minor;	168	argb.minor = minor;
169	argb.interface = NULL;	169	argb.interface = NULL;
170	/* eat the error, it will be in argb.interface */	170	/* eat the error, it will be in argb.interface */
171	retval = driver_for_each_device(&drv->drvwrap.driver, NULL, &argb,	171	retval = driver_for_each_device(&drv->drvwrap.driver, NULL, &argb,
172	__find_interface);	172	__find_interface);
173	return argb.interface;	173	return argb.interface;
174	}	174	}
175	EXPORT_SYMBOL_GPL(usb_find_interface);	175	EXPORT_SYMBOL_GPL(usb_find_interface);
176		176
177	/**	177	/**
178	* usb_release_dev - free a usb device structure when all users of it are finished.	178	* usb_release_dev - free a usb device structure when all users of it are finished.
179	* @dev: device that's been disconnected	179	* @dev: device that's been disconnected
180	*	180	*
181	* Will be called only by the device core when all users of this usb device are	181	* Will be called only by the device core when all users of this usb device are
182	* done.	182	* done.
183	*/	183	*/
184	static void usb_release_dev(struct device *dev)	184	static void usb_release_dev(struct device *dev)
185	{	185	{
186	struct usb_device *udev;	186	struct usb_device *udev;
187		187
188	udev = to_usb_device(dev);	188	udev = to_usb_device(dev);
189		189
190	usb_destroy_configuration(udev);	190	usb_destroy_configuration(udev);
191	usb_put_hcd(bus_to_hcd(udev->bus));	191	usb_put_hcd(bus_to_hcd(udev->bus));
192	kfree(udev->product);	192	kfree(udev->product);
193	kfree(udev->manufacturer);	193	kfree(udev->manufacturer);
194	kfree(udev->serial);	194	kfree(udev->serial);
195	kfree(udev);	195	kfree(udev);
196	}	196	}
197		197
198	#ifdef CONFIG_HOTPLUG	198	#ifdef CONFIG_HOTPLUG
199	static int usb_dev_uevent(struct device dev, struct kobj_uevent_env env)	199	static int usb_dev_uevent(struct device dev, struct kobj_uevent_env env)
200	{	200	{
201	struct usb_device *usb_dev;	201	struct usb_device *usb_dev;
202		202
203	usb_dev = to_usb_device(dev);	203	usb_dev = to_usb_device(dev);
204		204
205	if (add_uevent_var(env, "BUSNUM=%03d", usb_dev->bus->busnum))	205	if (add_uevent_var(env, "BUSNUM=%03d", usb_dev->bus->busnum))
206	return -ENOMEM;	206	return -ENOMEM;
207		207
208	if (add_uevent_var(env, "DEVNUM=%03d", usb_dev->devnum))	208	if (add_uevent_var(env, "DEVNUM=%03d", usb_dev->devnum))
209	return -ENOMEM;	209	return -ENOMEM;
210		210
211	return 0;	211	return 0;
212	}	212	}
213		213
214	#else	214	#else
215		215
216	static int usb_dev_uevent(struct device dev, struct kobj_uevent_env env)	216	static int usb_dev_uevent(struct device dev, struct kobj_uevent_env env)
217	{	217	{
218	return -ENODEV;	218	return -ENODEV;
219	}	219	}
220	#endif /* CONFIG_HOTPLUG */	220	#endif /* CONFIG_HOTPLUG */
221		221
222	#ifdef CONFIG_PM	222	#ifdef CONFIG_PM
223		223
224	static int ksuspend_usb_init(void)	224	static int ksuspend_usb_init(void)
225	{	225	{
226	/* This workqueue is supposed to be both freezable and	226	/* This workqueue is supposed to be both freezable and
227	* singlethreaded. Its job doesn't justify running on more	227	* singlethreaded. Its job doesn't justify running on more
228	* than one CPU.	228	* than one CPU.
229	*/	229	*/
230	ksuspend_usb_wq = create_freezeable_workqueue("ksuspend_usbd");	230	ksuspend_usb_wq = create_freezeable_workqueue("ksuspend_usbd");
231	if (!ksuspend_usb_wq)	231	if (!ksuspend_usb_wq)
232	return -ENOMEM;	232	return -ENOMEM;
233	return 0;	233	return 0;
234	}	234	}
235		235
236	static void ksuspend_usb_cleanup(void)	236	static void ksuspend_usb_cleanup(void)
237	{	237	{
238	destroy_workqueue(ksuspend_usb_wq);	238	destroy_workqueue(ksuspend_usb_wq);
239	}	239	}
240		240
241	/* USB device Power-Management thunks.	241	/* USB device Power-Management thunks.
242	* There's no need to distinguish here between quiescing a USB device	242	* There's no need to distinguish here between quiescing a USB device
243	* and powering it down; the generic_suspend() routine takes care of	243	* and powering it down; the generic_suspend() routine takes care of
244	* it by skipping the usb_port_suspend() call for a quiesce. And for	244	* it by skipping the usb_port_suspend() call for a quiesce. And for
245	* USB interfaces there's no difference at all.	245	* USB interfaces there's no difference at all.
246	*/	246	*/
247		247
248	static int usb_dev_prepare(struct device *dev)	248	static int usb_dev_prepare(struct device *dev)
249	{	249	{
250	return 0; /* Implement eventually? */	250	return 0; /* Implement eventually? */
251	}	251	}
252		252
253	static void usb_dev_complete(struct device *dev)	253	static void usb_dev_complete(struct device *dev)
254	{	254	{
255	/* Currently used only for rebinding interfaces */	255	/* Currently used only for rebinding interfaces */
256	usb_resume(dev); /* Implement eventually? */	256	usb_resume(dev); /* Implement eventually? */
257	}	257	}
258		258
259	static int usb_dev_suspend(struct device *dev)	259	static int usb_dev_suspend(struct device *dev)
260	{	260	{
261	return usb_suspend(dev, PMSG_SUSPEND);	261	return usb_suspend(dev, PMSG_SUSPEND);
262	}	262	}
263		263
264	static int usb_dev_resume(struct device *dev)	264	static int usb_dev_resume(struct device *dev)
265	{	265	{
266	return usb_resume(dev);	266	return usb_resume(dev);
267	}	267	}
268		268
269	static int usb_dev_freeze(struct device *dev)	269	static int usb_dev_freeze(struct device *dev)
270	{	270	{
271	return usb_suspend(dev, PMSG_FREEZE);	271	return usb_suspend(dev, PMSG_FREEZE);
272	}	272	}
273		273
274	static int usb_dev_thaw(struct device *dev)	274	static int usb_dev_thaw(struct device *dev)
275	{	275	{
276	return usb_resume(dev);	276	return usb_resume(dev);
277	}	277	}
278		278
279	static int usb_dev_poweroff(struct device *dev)	279	static int usb_dev_poweroff(struct device *dev)
280	{	280	{
281	return usb_suspend(dev, PMSG_HIBERNATE);	281	return usb_suspend(dev, PMSG_HIBERNATE);
282	}	282	}
283		283
284	static int usb_dev_restore(struct device *dev)	284	static int usb_dev_restore(struct device *dev)
285	{	285	{
286	return usb_resume(dev);	286	return usb_resume(dev);
287	}	287	}
288		288
289	static struct pm_ops usb_device_pm_ops = {	289	static struct dev_pm_ops usb_device_pm_ops = {
290	.prepare = usb_dev_prepare,	290	.prepare = usb_dev_prepare,
291	.complete = usb_dev_complete,	291	.complete = usb_dev_complete,
292	.suspend = usb_dev_suspend,	292	.suspend = usb_dev_suspend,
293	.resume = usb_dev_resume,	293	.resume = usb_dev_resume,
294	.freeze = usb_dev_freeze,	294	.freeze = usb_dev_freeze,
295	.thaw = usb_dev_thaw,	295	.thaw = usb_dev_thaw,
296	.poweroff = usb_dev_poweroff,	296	.poweroff = usb_dev_poweroff,
297	.restore = usb_dev_restore,	297	.restore = usb_dev_restore,
298	};	298	};
299		299
300	#else	300	#else
301		301
302	#define ksuspend_usb_init() 0	302	#define ksuspend_usb_init() 0
303	#define ksuspend_usb_cleanup() do {} while (0)	303	#define ksuspend_usb_cleanup() do {} while (0)
304	#define usb_device_pm_ops ((struct pm_ops )0)	304	#define usb_device_pm_ops ((struct dev_pm_ops )0)
305		305
306	#endif /* CONFIG_PM */	306	#endif /* CONFIG_PM */
307		307
308	struct device_type usb_device_type = {	308	struct device_type usb_device_type = {
309	.name = "usb_device",	309	.name = "usb_device",
310	.release = usb_release_dev,	310	.release = usb_release_dev,
311	.uevent = usb_dev_uevent,	311	.uevent = usb_dev_uevent,
312	.pm = &usb_device_pm_ops,	312	.pm = &usb_device_pm_ops,
313	};	313	};
314		314
315		315
316	/* Returns 1 if @usb_bus is WUSB, 0 otherwise */	316	/* Returns 1 if @usb_bus is WUSB, 0 otherwise */
317	static unsigned usb_bus_is_wusb(struct usb_bus *bus)	317	static unsigned usb_bus_is_wusb(struct usb_bus *bus)
318	{	318	{
319	struct usb_hcd *hcd = container_of(bus, struct usb_hcd, self);	319	struct usb_hcd *hcd = container_of(bus, struct usb_hcd, self);
320	return hcd->wireless;	320	return hcd->wireless;
321	}	321	}
322		322
323		323
324	/**	324	/**
325	* usb_alloc_dev - usb device constructor (usbcore-internal)	325	* usb_alloc_dev - usb device constructor (usbcore-internal)
326	* @parent: hub to which device is connected; null to allocate a root hub	326	* @parent: hub to which device is connected; null to allocate a root hub
327	* @bus: bus used to access the device	327	* @bus: bus used to access the device
328	* @port1: one-based index of port; ignored for root hubs	328	* @port1: one-based index of port; ignored for root hubs
329	* Context: !in_interrupt()	329	* Context: !in_interrupt()
330	*	330	*
331	* Only hub drivers (including virtual root hub drivers for host	331	* Only hub drivers (including virtual root hub drivers for host
332	* controllers) should ever call this.	332	* controllers) should ever call this.
333	*	333	*
334	* This call may not be used in a non-sleeping context.	334	* This call may not be used in a non-sleeping context.
335	*/	335	*/
336	struct usb_device usb_alloc_dev(struct usb_device parent,	336	struct usb_device usb_alloc_dev(struct usb_device parent,
337	struct usb_bus *bus, unsigned port1)	337	struct usb_bus *bus, unsigned port1)
338	{	338	{
339	struct usb_device *dev;	339	struct usb_device *dev;
340	struct usb_hcd *usb_hcd = container_of(bus, struct usb_hcd, self);	340	struct usb_hcd *usb_hcd = container_of(bus, struct usb_hcd, self);
341	unsigned root_hub = 0;	341	unsigned root_hub = 0;
342		342
343	dev = kzalloc(sizeof(*dev), GFP_KERNEL);	343	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
344	if (!dev)	344	if (!dev)
345	return NULL;	345	return NULL;
346		346
347	if (!usb_get_hcd(bus_to_hcd(bus))) {	347	if (!usb_get_hcd(bus_to_hcd(bus))) {
348	kfree(dev);	348	kfree(dev);
349	return NULL;	349	return NULL;
350	}	350	}
351		351
352	device_initialize(&dev->dev);	352	device_initialize(&dev->dev);
353	dev->dev.bus = &usb_bus_type;	353	dev->dev.bus = &usb_bus_type;
354	dev->dev.type = &usb_device_type;	354	dev->dev.type = &usb_device_type;
355	dev->dev.groups = usb_device_groups;	355	dev->dev.groups = usb_device_groups;
356	dev->dev.dma_mask = bus->controller->dma_mask;	356	dev->dev.dma_mask = bus->controller->dma_mask;
357	set_dev_node(&dev->dev, dev_to_node(bus->controller));	357	set_dev_node(&dev->dev, dev_to_node(bus->controller));
358	dev->state = USB_STATE_ATTACHED;	358	dev->state = USB_STATE_ATTACHED;
359	atomic_set(&dev->urbnum, 0);	359	atomic_set(&dev->urbnum, 0);
360		360
361	INIT_LIST_HEAD(&dev->ep0.urb_list);	361	INIT_LIST_HEAD(&dev->ep0.urb_list);
362	dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;	362	dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;
363	dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;	363	dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;
364	/* ep0 maxpacket comes later, from device descriptor */	364	/* ep0 maxpacket comes later, from device descriptor */
365	usb_enable_endpoint(dev, &dev->ep0);	365	usb_enable_endpoint(dev, &dev->ep0);
366	dev->can_submit = 1;	366	dev->can_submit = 1;
367		367
368	/* Save readable and stable topology id, distinguishing devices	368	/* Save readable and stable topology id, distinguishing devices
369	* by location for diagnostics, tools, driver model, etc. The	369	* by location for diagnostics, tools, driver model, etc. The
370	* string is a path along hub ports, from the root. Each device's	370	* string is a path along hub ports, from the root. Each device's
371	* dev->devpath will be stable until USB is re-cabled, and hubs	371	* dev->devpath will be stable until USB is re-cabled, and hubs
372	* are often labeled with these port numbers. The name isn't	372	* are often labeled with these port numbers. The name isn't
373	* as stable: bus->busnum changes easily from modprobe order,	373	* as stable: bus->busnum changes easily from modprobe order,
374	* cardbus or pci hotplugging, and so on.	374	* cardbus or pci hotplugging, and so on.
375	*/	375	*/
376	if (unlikely(!parent)) {	376	if (unlikely(!parent)) {
377	dev->devpath[0] = '0';	377	dev->devpath[0] = '0';
378		378
379	dev->dev.parent = bus->controller;	379	dev->dev.parent = bus->controller;
380	dev_set_name(&dev->dev, "usb%d", bus->busnum);	380	dev_set_name(&dev->dev, "usb%d", bus->busnum);
381	root_hub = 1;	381	root_hub = 1;
382	} else {	382	} else {
383	/* match any labeling on the hubs; it's one-based */	383	/* match any labeling on the hubs; it's one-based */
384	if (parent->devpath[0] == '0')	384	if (parent->devpath[0] == '0')
385	snprintf(dev->devpath, sizeof dev->devpath,	385	snprintf(dev->devpath, sizeof dev->devpath,
386	"%d", port1);	386	"%d", port1);
387	else	387	else
388	snprintf(dev->devpath, sizeof dev->devpath,	388	snprintf(dev->devpath, sizeof dev->devpath,
389	"%s.%d", parent->devpath, port1);	389	"%s.%d", parent->devpath, port1);
390		390
391	dev->dev.parent = &parent->dev;	391	dev->dev.parent = &parent->dev;
392	dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath);	392	dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath);
393		393
394	/* hub driver sets up TT records */	394	/* hub driver sets up TT records */
395	}	395	}
396		396
397	dev->portnum = port1;	397	dev->portnum = port1;
398	dev->bus = bus;	398	dev->bus = bus;
399	dev->parent = parent;	399	dev->parent = parent;
400	INIT_LIST_HEAD(&dev->filelist);	400	INIT_LIST_HEAD(&dev->filelist);
401		401
402	#ifdef CONFIG_PM	402	#ifdef CONFIG_PM
403	mutex_init(&dev->pm_mutex);	403	mutex_init(&dev->pm_mutex);
404	INIT_DELAYED_WORK(&dev->autosuspend, usb_autosuspend_work);	404	INIT_DELAYED_WORK(&dev->autosuspend, usb_autosuspend_work);
405	dev->autosuspend_delay = usb_autosuspend_delay * HZ;	405	dev->autosuspend_delay = usb_autosuspend_delay * HZ;
406	dev->connect_time = jiffies;	406	dev->connect_time = jiffies;
407	dev->active_duration = -jiffies;	407	dev->active_duration = -jiffies;
408	#endif	408	#endif
409	if (root_hub) /* Root hub always ok [and always wired] */	409	if (root_hub) /* Root hub always ok [and always wired] */
410	dev->authorized = 1;	410	dev->authorized = 1;
411	else {	411	else {
412	dev->authorized = usb_hcd->authorized_default;	412	dev->authorized = usb_hcd->authorized_default;
413	dev->wusb = usb_bus_is_wusb(bus)? 1 : 0;	413	dev->wusb = usb_bus_is_wusb(bus)? 1 : 0;
414	}	414	}
415	return dev;	415	return dev;
416	}	416	}
417		417
418	/**	418	/**
419	* usb_get_dev - increments the reference count of the usb device structure	419	* usb_get_dev - increments the reference count of the usb device structure
420	* @dev: the device being referenced	420	* @dev: the device being referenced
421	*	421	*
422	* Each live reference to a device should be refcounted.	422	* Each live reference to a device should be refcounted.
423	*	423	*
424	* Drivers for USB interfaces should normally record such references in	424	* Drivers for USB interfaces should normally record such references in
425	* their probe() methods, when they bind to an interface, and release	425	* their probe() methods, when they bind to an interface, and release
426	* them by calling usb_put_dev(), in their disconnect() methods.	426	* them by calling usb_put_dev(), in their disconnect() methods.
427	*	427	*
428	* A pointer to the device with the incremented reference counter is returned.	428	* A pointer to the device with the incremented reference counter is returned.
429	*/	429	*/
430	struct usb_device usb_get_dev(struct usb_device dev)	430	struct usb_device usb_get_dev(struct usb_device dev)
431	{	431	{
432	if (dev)	432	if (dev)
433	get_device(&dev->dev);	433	get_device(&dev->dev);
434	return dev;	434	return dev;
435	}	435	}
436	EXPORT_SYMBOL_GPL(usb_get_dev);	436	EXPORT_SYMBOL_GPL(usb_get_dev);
437		437
438	/**	438	/**
439	* usb_put_dev - release a use of the usb device structure	439	* usb_put_dev - release a use of the usb device structure
440	* @dev: device that's been disconnected	440	* @dev: device that's been disconnected
441	*	441	*
442	* Must be called when a user of a device is finished with it. When the last	442	* Must be called when a user of a device is finished with it. When the last
443	* user of the device calls this function, the memory of the device is freed.	443	* user of the device calls this function, the memory of the device is freed.
444	*/	444	*/
445	void usb_put_dev(struct usb_device *dev)	445	void usb_put_dev(struct usb_device *dev)
446	{	446	{
447	if (dev)	447	if (dev)
448	put_device(&dev->dev);	448	put_device(&dev->dev);
449	}	449	}
450	EXPORT_SYMBOL_GPL(usb_put_dev);	450	EXPORT_SYMBOL_GPL(usb_put_dev);
451		451
452	/**	452	/**
453	* usb_get_intf - increments the reference count of the usb interface structure	453	* usb_get_intf - increments the reference count of the usb interface structure
454	* @intf: the interface being referenced	454	* @intf: the interface being referenced
455	*	455	*
456	* Each live reference to a interface must be refcounted.	456	* Each live reference to a interface must be refcounted.
457	*	457	*
458	* Drivers for USB interfaces should normally record such references in	458	* Drivers for USB interfaces should normally record such references in
459	* their probe() methods, when they bind to an interface, and release	459	* their probe() methods, when they bind to an interface, and release
460	* them by calling usb_put_intf(), in their disconnect() methods.	460	* them by calling usb_put_intf(), in their disconnect() methods.
461	*	461	*
462	* A pointer to the interface with the incremented reference counter is	462	* A pointer to the interface with the incremented reference counter is
463	* returned.	463	* returned.
464	*/	464	*/
465	struct usb_interface usb_get_intf(struct usb_interface intf)	465	struct usb_interface usb_get_intf(struct usb_interface intf)
466	{	466	{
467	if (intf)	467	if (intf)
468	get_device(&intf->dev);	468	get_device(&intf->dev);
469	return intf;	469	return intf;
470	}	470	}
471	EXPORT_SYMBOL_GPL(usb_get_intf);	471	EXPORT_SYMBOL_GPL(usb_get_intf);
472		472
473	/**	473	/**
474	* usb_put_intf - release a use of the usb interface structure	474	* usb_put_intf - release a use of the usb interface structure
475	* @intf: interface that's been decremented	475	* @intf: interface that's been decremented
476	*	476	*
477	* Must be called when a user of an interface is finished with it. When the	477	* Must be called when a user of an interface is finished with it. When the
478	* last user of the interface calls this function, the memory of the interface	478	* last user of the interface calls this function, the memory of the interface
479	* is freed.	479	* is freed.
480	*/	480	*/
481	void usb_put_intf(struct usb_interface *intf)	481	void usb_put_intf(struct usb_interface *intf)
482	{	482	{
483	if (intf)	483	if (intf)
484	put_device(&intf->dev);	484	put_device(&intf->dev);
485	}	485	}
486	EXPORT_SYMBOL_GPL(usb_put_intf);	486	EXPORT_SYMBOL_GPL(usb_put_intf);
487		487
488	/* USB device locking	488	/* USB device locking
489	*	489	*
490	* USB devices and interfaces are locked using the semaphore in their	490	* USB devices and interfaces are locked using the semaphore in their
491	* embedded struct device. The hub driver guarantees that whenever a	491	* embedded struct device. The hub driver guarantees that whenever a
492	* device is connected or disconnected, drivers are called with the	492	* device is connected or disconnected, drivers are called with the
493	* USB device locked as well as their particular interface.	493	* USB device locked as well as their particular interface.
494	*	494	*
495	* Complications arise when several devices are to be locked at the same	495	* Complications arise when several devices are to be locked at the same
496	* time. Only hub-aware drivers that are part of usbcore ever have to	496	* time. Only hub-aware drivers that are part of usbcore ever have to
497	* do this; nobody else needs to worry about it. The rule for locking	497	* do this; nobody else needs to worry about it. The rule for locking
498	* is simple:	498	* is simple:
499	*	499	*
500	* When locking both a device and its parent, always lock the	500	* When locking both a device and its parent, always lock the
501	* the parent first.	501	* the parent first.
502	*/	502	*/
503		503
504	/**	504	/**
505	* usb_lock_device_for_reset - cautiously acquire the lock for a usb device structure	505	* usb_lock_device_for_reset - cautiously acquire the lock for a usb device structure
506	* @udev: device that's being locked	506	* @udev: device that's being locked
507	* @iface: interface bound to the driver making the request (optional)	507	* @iface: interface bound to the driver making the request (optional)
508	*	508	*
509	* Attempts to acquire the device lock, but fails if the device is	509	* Attempts to acquire the device lock, but fails if the device is
510	* NOTATTACHED or SUSPENDED, or if iface is specified and the interface	510	* NOTATTACHED or SUSPENDED, or if iface is specified and the interface
511	* is neither BINDING nor BOUND. Rather than sleeping to wait for the	511	* is neither BINDING nor BOUND. Rather than sleeping to wait for the
512	* lock, the routine polls repeatedly. This is to prevent deadlock with	512	* lock, the routine polls repeatedly. This is to prevent deadlock with
513	* disconnect; in some drivers (such as usb-storage) the disconnect()	513	* disconnect; in some drivers (such as usb-storage) the disconnect()
514	* or suspend() method will block waiting for a device reset to complete.	514	* or suspend() method will block waiting for a device reset to complete.
515	*	515	*
516	* Returns a negative error code for failure, otherwise 1 or 0 to indicate	516	* Returns a negative error code for failure, otherwise 1 or 0 to indicate
517	* that the device will or will not have to be unlocked. (0 can be	517	* that the device will or will not have to be unlocked. (0 can be
518	* returned when an interface is given and is BINDING, because in that	518	* returned when an interface is given and is BINDING, because in that
519	* case the driver already owns the device lock.)	519	* case the driver already owns the device lock.)
520	*/	520	*/
521	int usb_lock_device_for_reset(struct usb_device *udev,	521	int usb_lock_device_for_reset(struct usb_device *udev,
522	const struct usb_interface *iface)	522	const struct usb_interface *iface)
523	{	523	{
524	unsigned long jiffies_expire = jiffies + HZ;	524	unsigned long jiffies_expire = jiffies + HZ;
525		525
526	if (udev->state == USB_STATE_NOTATTACHED)	526	if (udev->state == USB_STATE_NOTATTACHED)
527	return -ENODEV;	527	return -ENODEV;
528	if (udev->state == USB_STATE_SUSPENDED)	528	if (udev->state == USB_STATE_SUSPENDED)
529	return -EHOSTUNREACH;	529	return -EHOSTUNREACH;
530	if (iface) {	530	if (iface) {
531	switch (iface->condition) {	531	switch (iface->condition) {
532	case USB_INTERFACE_BINDING:	532	case USB_INTERFACE_BINDING:
533	return 0;	533	return 0;
534	case USB_INTERFACE_BOUND:	534	case USB_INTERFACE_BOUND:
535	break;	535	break;
536	default:	536	default:
537	return -EINTR;	537	return -EINTR;
538	}	538	}
539	}	539	}
540		540
541	while (usb_trylock_device(udev) != 0) {	541	while (usb_trylock_device(udev) != 0) {
542		542
543	/* If we can't acquire the lock after waiting one second,	543	/* If we can't acquire the lock after waiting one second,
544	* we're probably deadlocked */	544	* we're probably deadlocked */
545	if (time_after(jiffies, jiffies_expire))	545	if (time_after(jiffies, jiffies_expire))
546	return -EBUSY;	546	return -EBUSY;
547		547
548	msleep(15);	548	msleep(15);
549	if (udev->state == USB_STATE_NOTATTACHED)	549	if (udev->state == USB_STATE_NOTATTACHED)
550	return -ENODEV;	550	return -ENODEV;
551	if (udev->state == USB_STATE_SUSPENDED)	551	if (udev->state == USB_STATE_SUSPENDED)
552	return -EHOSTUNREACH;	552	return -EHOSTUNREACH;
553	if (iface && iface->condition != USB_INTERFACE_BOUND)	553	if (iface && iface->condition != USB_INTERFACE_BOUND)
554	return -EINTR;	554	return -EINTR;
555	}	555	}
556	return 1;	556	return 1;
557	}	557	}
558	EXPORT_SYMBOL_GPL(usb_lock_device_for_reset);	558	EXPORT_SYMBOL_GPL(usb_lock_device_for_reset);
559		559
560	static struct usb_device match_device(struct usb_device dev,	560	static struct usb_device match_device(struct usb_device dev,
561	u16 vendor_id, u16 product_id)	561	u16 vendor_id, u16 product_id)
562	{	562	{
563	struct usb_device *ret_dev = NULL;	563	struct usb_device *ret_dev = NULL;
564	int child;	564	int child;
565		565
566	dev_dbg(&dev->dev, "check for vendor %04x, product %04x ...\n",	566	dev_dbg(&dev->dev, "check for vendor %04x, product %04x ...\n",
567	le16_to_cpu(dev->descriptor.idVendor),	567	le16_to_cpu(dev->descriptor.idVendor),
568	le16_to_cpu(dev->descriptor.idProduct));	568	le16_to_cpu(dev->descriptor.idProduct));
569		569
570	/* see if this device matches */	570	/* see if this device matches */
571	if ((vendor_id == le16_to_cpu(dev->descriptor.idVendor)) &&	571	if ((vendor_id == le16_to_cpu(dev->descriptor.idVendor)) &&
572	(product_id == le16_to_cpu(dev->descriptor.idProduct))) {	572	(product_id == le16_to_cpu(dev->descriptor.idProduct))) {
573	dev_dbg(&dev->dev, "matched this device!\n");	573	dev_dbg(&dev->dev, "matched this device!\n");
574	ret_dev = usb_get_dev(dev);	574	ret_dev = usb_get_dev(dev);
575	goto exit;	575	goto exit;
576	}	576	}
577		577
578	/* look through all of the children of this device */	578	/* look through all of the children of this device */
579	for (child = 0; child < dev->maxchild; ++child) {	579	for (child = 0; child < dev->maxchild; ++child) {
580	if (dev->children[child]) {	580	if (dev->children[child]) {
581	usb_lock_device(dev->children[child]);	581	usb_lock_device(dev->children[child]);
582	ret_dev = match_device(dev->children[child],	582	ret_dev = match_device(dev->children[child],
583	vendor_id, product_id);	583	vendor_id, product_id);
584	usb_unlock_device(dev->children[child]);	584	usb_unlock_device(dev->children[child]);
585	if (ret_dev)	585	if (ret_dev)
586	goto exit;	586	goto exit;
587	}	587	}
588	}	588	}
589	exit:	589	exit:
590	return ret_dev;	590	return ret_dev;
591	}	591	}
592		592
593	/**	593	/**
594	* usb_find_device - find a specific usb device in the system	594	* usb_find_device - find a specific usb device in the system
595	* @vendor_id: the vendor id of the device to find	595	* @vendor_id: the vendor id of the device to find
596	* @product_id: the product id of the device to find	596	* @product_id: the product id of the device to find
597	*	597	*
598	* Returns a pointer to a struct usb_device if such a specified usb	598	* Returns a pointer to a struct usb_device if such a specified usb
599	* device is present in the system currently. The usage count of the	599	* device is present in the system currently. The usage count of the
600	* device will be incremented if a device is found. Make sure to call	600	* device will be incremented if a device is found. Make sure to call
601	* usb_put_dev() when the caller is finished with the device.	601	* usb_put_dev() when the caller is finished with the device.
602	*	602	*
603	* If a device with the specified vendor and product id is not found,	603	* If a device with the specified vendor and product id is not found,
604	* NULL is returned.	604	* NULL is returned.
605	*/	605	*/
606	struct usb_device *usb_find_device(u16 vendor_id, u16 product_id)	606	struct usb_device *usb_find_device(u16 vendor_id, u16 product_id)
607	{	607	{
608	struct list_head *buslist;	608	struct list_head *buslist;
609	struct usb_bus *bus;	609	struct usb_bus *bus;
610	struct usb_device *dev = NULL;	610	struct usb_device *dev = NULL;
611		611
612	mutex_lock(&usb_bus_list_lock);	612	mutex_lock(&usb_bus_list_lock);
613	for (buslist = usb_bus_list.next;	613	for (buslist = usb_bus_list.next;
614	buslist != &usb_bus_list;	614	buslist != &usb_bus_list;
615	buslist = buslist->next) {	615	buslist = buslist->next) {
616	bus = container_of(buslist, struct usb_bus, bus_list);	616	bus = container_of(buslist, struct usb_bus, bus_list);
617	if (!bus->root_hub)	617	if (!bus->root_hub)
618	continue;	618	continue;
619	usb_lock_device(bus->root_hub);	619	usb_lock_device(bus->root_hub);
620	dev = match_device(bus->root_hub, vendor_id, product_id);	620	dev = match_device(bus->root_hub, vendor_id, product_id);
621	usb_unlock_device(bus->root_hub);	621	usb_unlock_device(bus->root_hub);
622	if (dev)	622	if (dev)
623	goto exit;	623	goto exit;
624	}	624	}
625	exit:	625	exit:
626	mutex_unlock(&usb_bus_list_lock);	626	mutex_unlock(&usb_bus_list_lock);
627	return dev;	627	return dev;
628	}	628	}
629		629
630	/**	630	/**
631	* usb_get_current_frame_number - return current bus frame number	631	* usb_get_current_frame_number - return current bus frame number
632	* @dev: the device whose bus is being queried	632	* @dev: the device whose bus is being queried
633	*	633	*
634	* Returns the current frame number for the USB host controller	634	* Returns the current frame number for the USB host controller
635	* used with the given USB device. This can be used when scheduling	635	* used with the given USB device. This can be used when scheduling
636	* isochronous requests.	636	* isochronous requests.
637	*	637	*
638	* Note that different kinds of host controller have different	638	* Note that different kinds of host controller have different
639	* "scheduling horizons". While one type might support scheduling only	639	* "scheduling horizons". While one type might support scheduling only
640	* 32 frames into the future, others could support scheduling up to	640	* 32 frames into the future, others could support scheduling up to
641	* 1024 frames into the future.	641	* 1024 frames into the future.
642	*/	642	*/
643	int usb_get_current_frame_number(struct usb_device *dev)	643	int usb_get_current_frame_number(struct usb_device *dev)
644	{	644	{
645	return usb_hcd_get_frame_number(dev);	645	return usb_hcd_get_frame_number(dev);
646	}	646	}
647	EXPORT_SYMBOL_GPL(usb_get_current_frame_number);	647	EXPORT_SYMBOL_GPL(usb_get_current_frame_number);
648		648
649	/-------------------------------------------------------------------/	649	/-------------------------------------------------------------------/
650	/*	650	/*
651	* __usb_get_extra_descriptor() finds a descriptor of specific type in the	651	* __usb_get_extra_descriptor() finds a descriptor of specific type in the
652	* extra field of the interface and endpoint descriptor structs.	652	* extra field of the interface and endpoint descriptor structs.
653	*/	653	*/
654		654
655	int __usb_get_extra_descriptor(char *buffer, unsigned size,	655	int __usb_get_extra_descriptor(char *buffer, unsigned size,
656	unsigned char type, void **ptr)	656	unsigned char type, void **ptr)
657	{	657	{
658	struct usb_descriptor_header *header;	658	struct usb_descriptor_header *header;
659		659
660	while (size >= sizeof(struct usb_descriptor_header)) {	660	while (size >= sizeof(struct usb_descriptor_header)) {
661	header = (struct usb_descriptor_header *)buffer;	661	header = (struct usb_descriptor_header *)buffer;
662		662
663	if (header->bLength < 2) {	663	if (header->bLength < 2) {
664	printk(KERN_ERR	664	printk(KERN_ERR
665	"%s: bogus descriptor, type %d length %d\n",	665	"%s: bogus descriptor, type %d length %d\n",
666	usbcore_name,	666	usbcore_name,
667	header->bDescriptorType,	667	header->bDescriptorType,
668	header->bLength);	668	header->bLength);
669	return -1;	669	return -1;
670	}	670	}
671		671
672	if (header->bDescriptorType == type) {	672	if (header->bDescriptorType == type) {
673	*ptr = header;	673	*ptr = header;
674	return 0;	674	return 0;
675	}	675	}
676		676
677	buffer += header->bLength;	677	buffer += header->bLength;
678	size -= header->bLength;	678	size -= header->bLength;
679	}	679	}
680	return -1;	680	return -1;
681	}	681	}
682	EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor);	682	EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor);
683		683
684	/**	684	/**
685	* usb_buffer_alloc - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP	685	* usb_buffer_alloc - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP
686	* @dev: device the buffer will be used with	686	* @dev: device the buffer will be used with
687	* @size: requested buffer size	687	* @size: requested buffer size
688	* @mem_flags: affect whether allocation may block	688	* @mem_flags: affect whether allocation may block
689	* @dma: used to return DMA address of buffer	689	* @dma: used to return DMA address of buffer
690	*	690	*
691	* Return value is either null (indicating no buffer could be allocated), or	691	* Return value is either null (indicating no buffer could be allocated), or
692	* the cpu-space pointer to a buffer that may be used to perform DMA to the	692	* the cpu-space pointer to a buffer that may be used to perform DMA to the
693	* specified device. Such cpu-space buffers are returned along with the DMA	693	* specified device. Such cpu-space buffers are returned along with the DMA
694	* address (through the pointer provided).	694	* address (through the pointer provided).
695	*	695	*
696	* These buffers are used with URB_NO_xxx_DMA_MAP set in urb->transfer_flags	696	* These buffers are used with URB_NO_xxx_DMA_MAP set in urb->transfer_flags
697	* to avoid behaviors like using "DMA bounce buffers", or thrashing IOMMU	697	* to avoid behaviors like using "DMA bounce buffers", or thrashing IOMMU
698	* hardware during URB completion/resubmit. The implementation varies between	698	* hardware during URB completion/resubmit. The implementation varies between
699	* platforms, depending on details of how DMA will work to this device.	699	* platforms, depending on details of how DMA will work to this device.
700	* Using these buffers also eliminates cacheline sharing problems on	700	* Using these buffers also eliminates cacheline sharing problems on
701	* architectures where CPU caches are not DMA-coherent. On systems without	701	* architectures where CPU caches are not DMA-coherent. On systems without
702	* bus-snooping caches, these buffers are uncached.	702	* bus-snooping caches, these buffers are uncached.
703	*	703	*
704	* When the buffer is no longer used, free it with usb_buffer_free().	704	* When the buffer is no longer used, free it with usb_buffer_free().
705	*/	705	*/
706	void usb_buffer_alloc(struct usb_device dev, size_t size, gfp_t mem_flags,	706	void usb_buffer_alloc(struct usb_device dev, size_t size, gfp_t mem_flags,
707	dma_addr_t *dma)	707	dma_addr_t *dma)
708	{	708	{
709	if (!dev \|\| !dev->bus)	709	if (!dev \|\| !dev->bus)
710	return NULL;	710	return NULL;
711	return hcd_buffer_alloc(dev->bus, size, mem_flags, dma);	711	return hcd_buffer_alloc(dev->bus, size, mem_flags, dma);
712	}	712	}
713	EXPORT_SYMBOL_GPL(usb_buffer_alloc);	713	EXPORT_SYMBOL_GPL(usb_buffer_alloc);
714		714
715	/**	715	/**
716	* usb_buffer_free - free memory allocated with usb_buffer_alloc()	716	* usb_buffer_free - free memory allocated with usb_buffer_alloc()
717	* @dev: device the buffer was used with	717	* @dev: device the buffer was used with
718	* @size: requested buffer size	718	* @size: requested buffer size
719	* @addr: CPU address of buffer	719	* @addr: CPU address of buffer
720	* @dma: DMA address of buffer	720	* @dma: DMA address of buffer
721	*	721	*
722	* This reclaims an I/O buffer, letting it be reused. The memory must have	722	* This reclaims an I/O buffer, letting it be reused. The memory must have
723	* been allocated using usb_buffer_alloc(), and the parameters must match	723	* been allocated using usb_buffer_alloc(), and the parameters must match
724	* those provided in that allocation request.	724	* those provided in that allocation request.
725	*/	725	*/
726	void usb_buffer_free(struct usb_device dev, size_t size, void addr,	726	void usb_buffer_free(struct usb_device dev, size_t size, void addr,
727	dma_addr_t dma)	727	dma_addr_t dma)
728	{	728	{
729	if (!dev \|\| !dev->bus)	729	if (!dev \|\| !dev->bus)
730	return;	730	return;
731	if (!addr)	731	if (!addr)
732	return;	732	return;
733	hcd_buffer_free(dev->bus, size, addr, dma);	733	hcd_buffer_free(dev->bus, size, addr, dma);
734	}	734	}
735	EXPORT_SYMBOL_GPL(usb_buffer_free);	735	EXPORT_SYMBOL_GPL(usb_buffer_free);
736		736
737	/**	737	/**
738	* usb_buffer_map - create DMA mapping(s) for an urb	738	* usb_buffer_map - create DMA mapping(s) for an urb
739	* @urb: urb whose transfer_buffer/setup_packet will be mapped	739	* @urb: urb whose transfer_buffer/setup_packet will be mapped
740	*	740	*
741	* Return value is either null (indicating no buffer could be mapped), or	741	* Return value is either null (indicating no buffer could be mapped), or
742	* the parameter. URB_NO_TRANSFER_DMA_MAP and URB_NO_SETUP_DMA_MAP are	742	* the parameter. URB_NO_TRANSFER_DMA_MAP and URB_NO_SETUP_DMA_MAP are
743	* added to urb->transfer_flags if the operation succeeds. If the device	743	* added to urb->transfer_flags if the operation succeeds. If the device
744	* is connected to this system through a non-DMA controller, this operation	744	* is connected to this system through a non-DMA controller, this operation
745	* always succeeds.	745	* always succeeds.
746	*	746	*
747	* This call would normally be used for an urb which is reused, perhaps	747	* This call would normally be used for an urb which is reused, perhaps
748	* as the target of a large periodic transfer, with usb_buffer_dmasync()	748	* as the target of a large periodic transfer, with usb_buffer_dmasync()
749	* calls to synchronize memory and dma state.	749	* calls to synchronize memory and dma state.
750	*	750	*
751	* Reverse the effect of this call with usb_buffer_unmap().	751	* Reverse the effect of this call with usb_buffer_unmap().
752	*/	752	*/
753	#if 0	753	#if 0
754	struct urb usb_buffer_map(struct urb urb)	754	struct urb usb_buffer_map(struct urb urb)
755	{	755	{
756	struct usb_bus *bus;	756	struct usb_bus *bus;
757	struct device *controller;	757	struct device *controller;
758		758
759	if (!urb	759	if (!urb
760	\|\| !urb->dev	760	\|\| !urb->dev
761	\|\| !(bus = urb->dev->bus)	761	\|\| !(bus = urb->dev->bus)
762	\|\| !(controller = bus->controller))	762	\|\| !(controller = bus->controller))
763	return NULL;	763	return NULL;
764		764
765	if (controller->dma_mask) {	765	if (controller->dma_mask) {
766	urb->transfer_dma = dma_map_single(controller,	766	urb->transfer_dma = dma_map_single(controller,
767	urb->transfer_buffer, urb->transfer_buffer_length,	767	urb->transfer_buffer, urb->transfer_buffer_length,
768	usb_pipein(urb->pipe)	768	usb_pipein(urb->pipe)
769	? DMA_FROM_DEVICE : DMA_TO_DEVICE);	769	? DMA_FROM_DEVICE : DMA_TO_DEVICE);
770	if (usb_pipecontrol(urb->pipe))	770	if (usb_pipecontrol(urb->pipe))
771	urb->setup_dma = dma_map_single(controller,	771	urb->setup_dma = dma_map_single(controller,
772	urb->setup_packet,	772	urb->setup_packet,
773	sizeof(struct usb_ctrlrequest),	773	sizeof(struct usb_ctrlrequest),
774	DMA_TO_DEVICE);	774	DMA_TO_DEVICE);
775	/* FIXME generic api broken like pci, can't report errors */	775	/* FIXME generic api broken like pci, can't report errors */
776	/* if (urb->transfer_dma == DMA_ADDR_INVALID) return 0; */	776	/* if (urb->transfer_dma == DMA_ADDR_INVALID) return 0; */
777	} else	777	} else
778	urb->transfer_dma = ~0;	778	urb->transfer_dma = ~0;
779	urb->transfer_flags \|= (URB_NO_TRANSFER_DMA_MAP	779	urb->transfer_flags \|= (URB_NO_TRANSFER_DMA_MAP
780	\| URB_NO_SETUP_DMA_MAP);	780	\| URB_NO_SETUP_DMA_MAP);
781	return urb;	781	return urb;
782	}	782	}
783	EXPORT_SYMBOL_GPL(usb_buffer_map);	783	EXPORT_SYMBOL_GPL(usb_buffer_map);
784	#endif /* 0 */	784	#endif /* 0 */
785		785
786	/* XXX DISABLED, no users currently. If you wish to re-enable this	786	/* XXX DISABLED, no users currently. If you wish to re-enable this
787	* XXX please determine whether the sync is to transfer ownership of	787	* XXX please determine whether the sync is to transfer ownership of
788	* XXX the buffer from device to cpu or vice verse, and thusly use the	788	* XXX the buffer from device to cpu or vice verse, and thusly use the
789	* XXX appropriate _for_{cpu,device}() method. -DaveM	789	* XXX appropriate _for_{cpu,device}() method. -DaveM
790	*/	790	*/
791	#if 0	791	#if 0
792		792
793	/**	793	/**
794	* usb_buffer_dmasync - synchronize DMA and CPU view of buffer(s)	794	* usb_buffer_dmasync - synchronize DMA and CPU view of buffer(s)
795	* @urb: urb whose transfer_buffer/setup_packet will be synchronized	795	* @urb: urb whose transfer_buffer/setup_packet will be synchronized
796	*/	796	*/
797	void usb_buffer_dmasync(struct urb *urb)	797	void usb_buffer_dmasync(struct urb *urb)
798	{	798	{
799	struct usb_bus *bus;	799	struct usb_bus *bus;
800	struct device *controller;	800	struct device *controller;
801		801
802	if (!urb	802	if (!urb
803	\|\| !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)	803	\|\| !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
804	\|\| !urb->dev	804	\|\| !urb->dev
805	\|\| !(bus = urb->dev->bus)	805	\|\| !(bus = urb->dev->bus)
806	\|\| !(controller = bus->controller))	806	\|\| !(controller = bus->controller))
807	return;	807	return;
808		808
809	if (controller->dma_mask) {	809	if (controller->dma_mask) {
810	dma_sync_single(controller,	810	dma_sync_single(controller,
811	urb->transfer_dma, urb->transfer_buffer_length,	811	urb->transfer_dma, urb->transfer_buffer_length,
812	usb_pipein(urb->pipe)	812	usb_pipein(urb->pipe)
813	? DMA_FROM_DEVICE : DMA_TO_DEVICE);	813	? DMA_FROM_DEVICE : DMA_TO_DEVICE);
814	if (usb_pipecontrol(urb->pipe))	814	if (usb_pipecontrol(urb->pipe))
815	dma_sync_single(controller,	815	dma_sync_single(controller,
816	urb->setup_dma,	816	urb->setup_dma,
817	sizeof(struct usb_ctrlrequest),	817	sizeof(struct usb_ctrlrequest),
818	DMA_TO_DEVICE);	818	DMA_TO_DEVICE);
819	}	819	}
820	}	820	}
821	EXPORT_SYMBOL_GPL(usb_buffer_dmasync);	821	EXPORT_SYMBOL_GPL(usb_buffer_dmasync);
822	#endif	822	#endif
823		823
824	/**	824	/**
825	* usb_buffer_unmap - free DMA mapping(s) for an urb	825	* usb_buffer_unmap - free DMA mapping(s) for an urb
826	* @urb: urb whose transfer_buffer will be unmapped	826	* @urb: urb whose transfer_buffer will be unmapped
827	*	827	*
828	* Reverses the effect of usb_buffer_map().	828	* Reverses the effect of usb_buffer_map().
829	*/	829	*/
830	#if 0	830	#if 0
831	void usb_buffer_unmap(struct urb *urb)	831	void usb_buffer_unmap(struct urb *urb)
832	{	832	{
833	struct usb_bus *bus;	833	struct usb_bus *bus;
834	struct device *controller;	834	struct device *controller;
835		835
836	if (!urb	836	if (!urb
837	\|\| !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)	837	\|\| !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
838	\|\| !urb->dev	838	\|\| !urb->dev
839	\|\| !(bus = urb->dev->bus)	839	\|\| !(bus = urb->dev->bus)
840	\|\| !(controller = bus->controller))	840	\|\| !(controller = bus->controller))
841	return;	841	return;
842		842
843	if (controller->dma_mask) {	843	if (controller->dma_mask) {
844	dma_unmap_single(controller,	844	dma_unmap_single(controller,
845	urb->transfer_dma, urb->transfer_buffer_length,	845	urb->transfer_dma, urb->transfer_buffer_length,
846	usb_pipein(urb->pipe)	846	usb_pipein(urb->pipe)
847	? DMA_FROM_DEVICE : DMA_TO_DEVICE);	847	? DMA_FROM_DEVICE : DMA_TO_DEVICE);
848	if (usb_pipecontrol(urb->pipe))	848	if (usb_pipecontrol(urb->pipe))
849	dma_unmap_single(controller,	849	dma_unmap_single(controller,
850	urb->setup_dma,	850	urb->setup_dma,
851	sizeof(struct usb_ctrlrequest),	851	sizeof(struct usb_ctrlrequest),
852	DMA_TO_DEVICE);	852	DMA_TO_DEVICE);
853	}	853	}
854	urb->transfer_flags &= ~(URB_NO_TRANSFER_DMA_MAP	854	urb->transfer_flags &= ~(URB_NO_TRANSFER_DMA_MAP
855	\| URB_NO_SETUP_DMA_MAP);	855	\| URB_NO_SETUP_DMA_MAP);
856	}	856	}
857	EXPORT_SYMBOL_GPL(usb_buffer_unmap);	857	EXPORT_SYMBOL_GPL(usb_buffer_unmap);
858	#endif /* 0 */	858	#endif /* 0 */
859		859
860	/**	860	/**
861	* usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint	861	* usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint
862	* @dev: device to which the scatterlist will be mapped	862	* @dev: device to which the scatterlist will be mapped
863	* @is_in: mapping transfer direction	863	* @is_in: mapping transfer direction
864	* @sg: the scatterlist to map	864	* @sg: the scatterlist to map
865	* @nents: the number of entries in the scatterlist	865	* @nents: the number of entries in the scatterlist
866	*	866	*
867	* Return value is either < 0 (indicating no buffers could be mapped), or	867	* Return value is either < 0 (indicating no buffers could be mapped), or
868	* the number of DMA mapping array entries in the scatterlist.	868	* the number of DMA mapping array entries in the scatterlist.
869	*	869	*
870	* The caller is responsible for placing the resulting DMA addresses from	870	* The caller is responsible for placing the resulting DMA addresses from
871	* the scatterlist into URB transfer buffer pointers, and for setting the	871	* the scatterlist into URB transfer buffer pointers, and for setting the
872	* URB_NO_TRANSFER_DMA_MAP transfer flag in each of those URBs.	872	* URB_NO_TRANSFER_DMA_MAP transfer flag in each of those URBs.
873	*	873	*
874	* Top I/O rates come from queuing URBs, instead of waiting for each one	874	* Top I/O rates come from queuing URBs, instead of waiting for each one
875	* to complete before starting the next I/O. This is particularly easy	875	* to complete before starting the next I/O. This is particularly easy
876	* to do with scatterlists. Just allocate and submit one URB for each DMA	876	* to do with scatterlists. Just allocate and submit one URB for each DMA
877	* mapping entry returned, stopping on the first error or when all succeed.	877	* mapping entry returned, stopping on the first error or when all succeed.
878	* Better yet, use the usb_sg_*() calls, which do that (and more) for you.	878	* Better yet, use the usb_sg_*() calls, which do that (and more) for you.
879	*	879	*
880	* This call would normally be used when translating scatterlist requests,	880	* This call would normally be used when translating scatterlist requests,
881	* rather than usb_buffer_map(), since on some hardware (with IOMMUs) it	881	* rather than usb_buffer_map(), since on some hardware (with IOMMUs) it
882	* may be able to coalesce mappings for improved I/O efficiency.	882	* may be able to coalesce mappings for improved I/O efficiency.
883	*	883	*
884	* Reverse the effect of this call with usb_buffer_unmap_sg().	884	* Reverse the effect of this call with usb_buffer_unmap_sg().
885	*/	885	*/
886	int usb_buffer_map_sg(const struct usb_device *dev, int is_in,	886	int usb_buffer_map_sg(const struct usb_device *dev, int is_in,
887	struct scatterlist *sg, int nents)	887	struct scatterlist *sg, int nents)
888	{	888	{
889	struct usb_bus *bus;	889	struct usb_bus *bus;
890	struct device *controller;	890	struct device *controller;
891		891
892	if (!dev	892	if (!dev
893	\|\| !(bus = dev->bus)	893	\|\| !(bus = dev->bus)
894	\|\| !(controller = bus->controller)	894	\|\| !(controller = bus->controller)
895	\|\| !controller->dma_mask)	895	\|\| !controller->dma_mask)
896	return -1;	896	return -1;
897		897
898	/* FIXME generic api broken like pci, can't report errors */	898	/* FIXME generic api broken like pci, can't report errors */
899	return dma_map_sg(controller, sg, nents,	899	return dma_map_sg(controller, sg, nents,
900	is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);	900	is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
901	}	901	}
902	EXPORT_SYMBOL_GPL(usb_buffer_map_sg);	902	EXPORT_SYMBOL_GPL(usb_buffer_map_sg);
903		903
904	/* XXX DISABLED, no users currently. If you wish to re-enable this	904	/* XXX DISABLED, no users currently. If you wish to re-enable this
905	* XXX please determine whether the sync is to transfer ownership of	905	* XXX please determine whether the sync is to transfer ownership of
906	* XXX the buffer from device to cpu or vice verse, and thusly use the	906	* XXX the buffer from device to cpu or vice verse, and thusly use the
907	* XXX appropriate _for_{cpu,device}() method. -DaveM	907	* XXX appropriate _for_{cpu,device}() method. -DaveM
908	*/	908	*/
909	#if 0	909	#if 0
910		910
911	/**	911	/**
912	* usb_buffer_dmasync_sg - synchronize DMA and CPU view of scatterlist buffer(s)	912	* usb_buffer_dmasync_sg - synchronize DMA and CPU view of scatterlist buffer(s)
913	* @dev: device to which the scatterlist will be mapped	913	* @dev: device to which the scatterlist will be mapped
914	* @is_in: mapping transfer direction	914	* @is_in: mapping transfer direction
915	* @sg: the scatterlist to synchronize	915	* @sg: the scatterlist to synchronize
916	* @n_hw_ents: the positive return value from usb_buffer_map_sg	916	* @n_hw_ents: the positive return value from usb_buffer_map_sg
917	*	917	*
918	* Use this when you are re-using a scatterlist's data buffers for	918	* Use this when you are re-using a scatterlist's data buffers for
919	* another USB request.	919	* another USB request.
920	*/	920	*/
921	void usb_buffer_dmasync_sg(const struct usb_device *dev, int is_in,	921	void usb_buffer_dmasync_sg(const struct usb_device *dev, int is_in,
922	struct scatterlist *sg, int n_hw_ents)	922	struct scatterlist *sg, int n_hw_ents)
923	{	923	{
924	struct usb_bus *bus;	924	struct usb_bus *bus;
925	struct device *controller;	925	struct device *controller;
926		926
927	if (!dev	927	if (!dev
928	\|\| !(bus = dev->bus)	928	\|\| !(bus = dev->bus)
929	\|\| !(controller = bus->controller)	929	\|\| !(controller = bus->controller)
930	\|\| !controller->dma_mask)	930	\|\| !controller->dma_mask)
931	return;	931	return;
932		932
933	dma_sync_sg(controller, sg, n_hw_ents,	933	dma_sync_sg(controller, sg, n_hw_ents,
934	is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);	934	is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
935	}	935	}
936	EXPORT_SYMBOL_GPL(usb_buffer_dmasync_sg);	936	EXPORT_SYMBOL_GPL(usb_buffer_dmasync_sg);
937	#endif	937	#endif
938		938
939	/**	939	/**
940	* usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist	940	* usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist
941	* @dev: device to which the scatterlist will be mapped	941	* @dev: device to which the scatterlist will be mapped
942	* @is_in: mapping transfer direction	942	* @is_in: mapping transfer direction
943	* @sg: the scatterlist to unmap	943	* @sg: the scatterlist to unmap
944	* @n_hw_ents: the positive return value from usb_buffer_map_sg	944	* @n_hw_ents: the positive return value from usb_buffer_map_sg
945	*	945	*
946	* Reverses the effect of usb_buffer_map_sg().	946	* Reverses the effect of usb_buffer_map_sg().
947	*/	947	*/
948	void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in,	948	void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in,
949	struct scatterlist *sg, int n_hw_ents)	949	struct scatterlist *sg, int n_hw_ents)
950	{	950	{
951	struct usb_bus *bus;	951	struct usb_bus *bus;
952	struct device *controller;	952	struct device *controller;
953		953
954	if (!dev	954	if (!dev
955	\|\| !(bus = dev->bus)	955	\|\| !(bus = dev->bus)
956	\|\| !(controller = bus->controller)	956	\|\| !(controller = bus->controller)
957	\|\| !controller->dma_mask)	957	\|\| !controller->dma_mask)
958	return;	958	return;
959		959
960	dma_unmap_sg(controller, sg, n_hw_ents,	960	dma_unmap_sg(controller, sg, n_hw_ents,
961	is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);	961	is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
962	}	962	}
963	EXPORT_SYMBOL_GPL(usb_buffer_unmap_sg);	963	EXPORT_SYMBOL_GPL(usb_buffer_unmap_sg);
964		964
965	/* format to disable USB on kernel command line is: nousb */	965	/* format to disable USB on kernel command line is: nousb */
966	__module_param_call("", nousb, param_set_bool, param_get_bool, &nousb, 0444);	966	__module_param_call("", nousb, param_set_bool, param_get_bool, &nousb, 0444);
967		967
968	/*	968	/*
969	* for external read access to <nousb>	969	* for external read access to <nousb>
970	*/	970	*/
971	int usb_disabled(void)	971	int usb_disabled(void)
972	{	972	{
973	return nousb;	973	return nousb;
974	}	974	}
975	EXPORT_SYMBOL_GPL(usb_disabled);	975	EXPORT_SYMBOL_GPL(usb_disabled);
976		976
977	/*	977	/*
978	* Init	978	* Init
979	*/	979	*/
980	static int __init usb_init(void)	980	static int __init usb_init(void)
981	{	981	{
982	int retval;	982	int retval;
983	if (nousb) {	983	if (nousb) {
984	pr_info("%s: USB support disabled\n", usbcore_name);	984	pr_info("%s: USB support disabled\n", usbcore_name);
985	return 0;	985	return 0;
986	}	986	}
987		987
988	retval = ksuspend_usb_init();	988	retval = ksuspend_usb_init();
989	if (retval)	989	if (retval)
990	goto out;	990	goto out;
991	retval = bus_register(&usb_bus_type);	991	retval = bus_register(&usb_bus_type);
992	if (retval)	992	if (retval)
993	goto bus_register_failed;	993	goto bus_register_failed;
994	retval = usb_host_init();	994	retval = usb_host_init();
995	if (retval)	995	if (retval)
996	goto host_init_failed;	996	goto host_init_failed;
997	retval = usb_major_init();	997	retval = usb_major_init();
998	if (retval)	998	if (retval)
999	goto major_init_failed;	999	goto major_init_failed;
1000	retval = usb_register(&usbfs_driver);	1000	retval = usb_register(&usbfs_driver);
1001	if (retval)	1001	if (retval)
1002	goto driver_register_failed;	1002	goto driver_register_failed;
1003	retval = usb_devio_init();	1003	retval = usb_devio_init();
1004	if (retval)	1004	if (retval)
1005	goto usb_devio_init_failed;	1005	goto usb_devio_init_failed;
1006	retval = usbfs_init();	1006	retval = usbfs_init();
1007	if (retval)	1007	if (retval)
1008	goto fs_init_failed;	1008	goto fs_init_failed;
1009	retval = usb_hub_init();	1009	retval = usb_hub_init();
1010	if (retval)	1010	if (retval)
1011	goto hub_init_failed;	1011	goto hub_init_failed;
1012	retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE);	1012	retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE);
1013	if (!retval)	1013	if (!retval)
1014	goto out;	1014	goto out;
1015		1015
1016	usb_hub_cleanup();	1016	usb_hub_cleanup();
1017	hub_init_failed:	1017	hub_init_failed:
1018	usbfs_cleanup();	1018	usbfs_cleanup();
1019	fs_init_failed:	1019	fs_init_failed:
1020	usb_devio_cleanup();	1020	usb_devio_cleanup();
1021	usb_devio_init_failed:	1021	usb_devio_init_failed:
1022	usb_deregister(&usbfs_driver);	1022	usb_deregister(&usbfs_driver);
1023	driver_register_failed:	1023	driver_register_failed:
1024	usb_major_cleanup();	1024	usb_major_cleanup();
1025	major_init_failed:	1025	major_init_failed:
1026	usb_host_cleanup();	1026	usb_host_cleanup();
1027	host_init_failed:	1027	host_init_failed:
1028	bus_unregister(&usb_bus_type);	1028	bus_unregister(&usb_bus_type);
1029	bus_register_failed:	1029	bus_register_failed:
1030	ksuspend_usb_cleanup();	1030	ksuspend_usb_cleanup();
1031	out:	1031	out:
1032	return retval;	1032	return retval;
1033	}	1033	}
1034		1034
1035	/*	1035	/*
1036	* Cleanup	1036	* Cleanup
1037	*/	1037	*/
1038	static void __exit usb_exit(void)	1038	static void __exit usb_exit(void)
1039	{	1039	{
1040	/* This will matter if shutdown/reboot does exitcalls. */	1040	/* This will matter if shutdown/reboot does exitcalls. */
1041	if (nousb)	1041	if (nousb)
1042	return;	1042	return;
1043		1043
1044	usb_deregister_device_driver(&usb_generic_driver);	1044	usb_deregister_device_driver(&usb_generic_driver);
1045	usb_major_cleanup();	1045	usb_major_cleanup();
1046	usbfs_cleanup();	1046	usbfs_cleanup();
1047	usb_deregister(&usbfs_driver);	1047	usb_deregister(&usbfs_driver);
1048	usb_devio_cleanup();	1048	usb_devio_cleanup();
1049	usb_hub_cleanup();	1049	usb_hub_cleanup();
1050	usb_host_cleanup();	1050	usb_host_cleanup();
1051	bus_unregister(&usb_bus_type);	1051	bus_unregister(&usb_bus_type);
1052	ksuspend_usb_cleanup();	1052	ksuspend_usb_cleanup();
1053	}	1053	}
1054		1054
1055	subsys_initcall(usb_init);	1055	subsys_initcall(usb_init);
1056	module_exit(usb_exit);	1056	module_exit(usb_exit);
1057	MODULE_LICENSE("GPL");	1057	MODULE_LICENSE("GPL");
1058		1058

include/linux/device.h

Diff comments View file @ adf0949

include/linux/pci.h

Diff comments View file @ adf0949

 /*
  *	pci.h
  *
  *	PCI defines and function prototypes
  *	Copyright 1994, Drew Eckhardt
  *	Copyright 1997--1999 Martin Mares <mj@ucw.cz>
  *
  *	For more information, please consult the following manuals (look at
  *	http://www.pcisig.com/ for how to get them):
  *
  *	PCI BIOS Specification
  *	PCI Local Bus Specification
  *	PCI to PCI Bridge Specification
  *	PCI System Design Guide
  */
 #ifndef LINUX_PCI_H
 #define LINUX_PCI_H
 #include <linux/pci_regs.h>	/* The pci register defines */
 /*
  * The PCI interface treats multi-function devices as independent
  * devices.  The slot/function address of each device is encoded
  * in a single byte as follows:
  *
  *	7:3 = slot
  *	2:0 = function
  */
 #define PCI_DEVFN(slot, func)	((((slot) & 0x1f) << 3) | ((func) & 0x07))
 #define PCI_SLOT(devfn)		(((devfn) >> 3) & 0x1f)
 #define PCI_FUNC(devfn)		((devfn) & 0x07)
 /* Ioctls for /proc/bus/pci/X/Y nodes. */
 #define PCIIOC_BASE		('P' << 24 | 'C' << 16 | 'I' << 8)
 #define PCIIOC_CONTROLLER	(PCIIOC_BASE | 0x00)	/* Get controller for PCI device. */
 #define PCIIOC_MMAP_IS_IO	(PCIIOC_BASE | 0x01)	/* Set mmap state to I/O space. */
 #define PCIIOC_MMAP_IS_MEM	(PCIIOC_BASE | 0x02)	/* Set mmap state to MEM space. */
 #define PCIIOC_WRITE_COMBINE	(PCIIOC_BASE | 0x03)	/* Enable/disable write-combining. */
 #ifdef __KERNEL__
 #include <linux/mod_devicetable.h>
 #include <linux/types.h>
 #include <linux/init.h>
 #include <linux/ioport.h>
 #include <linux/list.h>
 #include <linux/compiler.h>
 #include <linux/errno.h>
 #include <linux/kobject.h>
 #include <asm/atomic.h>
 #include <linux/device.h>
 #include <linux/io.h>
 /* Include the ID list */
 #include <linux/pci_ids.h>
 /* pci_slot represents a physical slot */
 struct pci_slot {
 	struct pci_bus *bus;		/* The bus this slot is on */
 	struct list_head list;		/* node in list of slots on this bus */
 	struct hotplug_slot *hotplug;	/* Hotplug info (migrate over time) */
 	unsigned char number;		/* PCI_SLOT(pci_dev->devfn) */
 	struct kobject kobj;
 };
 static inline const char *pci_slot_name(const struct pci_slot *slot)
 {
 	return kobject_name(&slot->kobj);
 }
 /* File state for mmap()s on /proc/bus/pci/X/Y */
 enum pci_mmap_state {
 	pci_mmap_io,
 	pci_mmap_mem
 };
 /* This defines the direction arg to the DMA mapping routines. */
 #define PCI_DMA_BIDIRECTIONAL	0
 #define PCI_DMA_TODEVICE	1
 #define PCI_DMA_FROMDEVICE	2
 #define PCI_DMA_NONE		3
 #define DEVICE_COUNT_RESOURCE	12
 typedef int __bitwise pci_power_t;
 #define PCI_D0		((pci_power_t __force) 0)
 #define PCI_D1		((pci_power_t __force) 1)
 #define PCI_D2		((pci_power_t __force) 2)
 #define PCI_D3hot	((pci_power_t __force) 3)
 #define PCI_D3cold	((pci_power_t __force) 4)
 #define PCI_UNKNOWN	((pci_power_t __force) 5)
 #define PCI_POWER_ERROR	((pci_power_t __force) -1)
 /** The pci_channel state describes connectivity between the CPU and
  *  the pci device.  If some PCI bus between here and the pci device
  *  has crashed or locked up, this info is reflected here.
  */
 typedef unsigned int __bitwise pci_channel_state_t;
 enum pci_channel_state {
 	/* I/O channel is in normal state */
 	pci_channel_io_normal = (__force pci_channel_state_t) 1,
 	/* I/O to channel is blocked */
 	pci_channel_io_frozen = (__force pci_channel_state_t) 2,
 	/* PCI card is dead */
 	pci_channel_io_perm_failure = (__force pci_channel_state_t) 3,
 };
 typedef unsigned int __bitwise pcie_reset_state_t;
 enum pcie_reset_state {
 	/* Reset is NOT asserted (Use to deassert reset) */
 	pcie_deassert_reset = (__force pcie_reset_state_t) 1,
 	/* Use #PERST to reset PCI-E device */
 	pcie_warm_reset = (__force pcie_reset_state_t) 2,
 	/* Use PCI-E Hot Reset to reset device */
 	pcie_hot_reset = (__force pcie_reset_state_t) 3
 };
 typedef unsigned short __bitwise pci_dev_flags_t;
 enum pci_dev_flags {
 	/* INTX_DISABLE in PCI_COMMAND register disables MSI
 	 * generation too.
 	 */
 	PCI_DEV_FLAGS_MSI_INTX_DISABLE_BUG = (__force pci_dev_flags_t) 1,
 	/* Device configuration is irrevocably lost if disabled into D3 */
 	PCI_DEV_FLAGS_NO_D3 = (__force pci_dev_flags_t) 2,
 };
 enum pci_irq_reroute_variant {
 	INTEL_IRQ_REROUTE_VARIANT = 1,
 	MAX_IRQ_REROUTE_VARIANTS = 3
 };
 typedef unsigned short __bitwise pci_bus_flags_t;
 enum pci_bus_flags {
 	PCI_BUS_FLAGS_NO_MSI   = (__force pci_bus_flags_t) 1,
 	PCI_BUS_FLAGS_NO_MMRBC = (__force pci_bus_flags_t) 2,
 };
 struct pci_cap_saved_state {
 	struct hlist_node next;
 	char cap_nr;
 	u32 data[0];
 };
 struct pcie_link_state;
 struct pci_vpd;
 /*
  * The pci_dev structure is used to describe PCI devices.
  */
 struct pci_dev {
 	struct list_head bus_list;	/* node in per-bus list */
 	struct pci_bus	*bus;		/* bus this device is on */
 	struct pci_bus	*subordinate;	/* bus this device bridges to */
 	void		*sysdata;	/* hook for sys-specific extension */
 	struct proc_dir_entry *procent;	/* device entry in /proc/bus/pci */
 	struct pci_slot	*slot;		/* Physical slot this device is in */
 	unsigned int	devfn;		/* encoded device & function index */
 	unsigned short	vendor;
 	unsigned short	device;
 	unsigned short	subsystem_vendor;
 	unsigned short	subsystem_device;
 	unsigned int	class;		/* 3 bytes: (base,sub,prog-if) */
 	u8		revision;	/* PCI revision, low byte of class word */
 	u8		hdr_type;	/* PCI header type (`multi' flag masked out) */
 	u8		pcie_type;	/* PCI-E device/port type */
 	u8		rom_base_reg;	/* which config register controls the ROM */
 	u8		pin;  		/* which interrupt pin this device uses */
 	struct pci_driver *driver;	/* which driver has allocated this device */
 	u64		dma_mask;	/* Mask of the bits of bus address this
 					   device implements.  Normally this is
 					   0xffffffff.  You only need to change
 					   this if your device has broken DMA
 					   or supports 64-bit transfers.  */
 	struct device_dma_parameters dma_parms;
 	pci_power_t     current_state;  /* Current operating state. In ACPI-speak,
 					   this is D0-D3, D0 being fully functional,
 					   and D3 being off. */
 	int		pm_cap;		/* PM capability offset in the
 					   configuration space */
 	unsigned int	pme_support:5;	/* Bitmask of states from which PME#
 					   can be generated */
 	unsigned int	d1_support:1;	/* Low power state D1 is supported */
 	unsigned int	d2_support:1;	/* Low power state D2 is supported */
 	unsigned int	no_d1d2:1;	/* Only allow D0 and D3 */
 #ifdef CONFIG_PCIEASPM
 	struct pcie_link_state	*link_state;	/* ASPM link state. */
 #endif
 	pci_channel_state_t error_state;	/* current connectivity state */
 	struct	device	dev;		/* Generic device interface */
 	int		cfg_size;	/* Size of configuration space */
 	/*
 	 * Instead of touching interrupt line and base address registers
 	 * directly, use the values stored here. They might be different!
 	 */
 	unsigned int	irq;
 	struct resource resource[DEVICE_COUNT_RESOURCE]; /* I/O and memory regions + expansion ROMs */
 	/* These fields are used by common fixups */
 	unsigned int	transparent:1;	/* Transparent PCI bridge */
 	unsigned int	multifunction:1;/* Part of multi-function device */
 	/* keep track of device state */
 	unsigned int	is_added:1;
 	unsigned int	is_busmaster:1; /* device is busmaster */
 	unsigned int	no_msi:1;	/* device may not use msi */
 	unsigned int	block_ucfg_access:1;	/* userspace config space access is blocked */
 	unsigned int	broken_parity_status:1;	/* Device generates false positive parity */
 	unsigned int	irq_reroute_variant:2;	/* device needs IRQ rerouting variant */
 	unsigned int 	msi_enabled:1;
 	unsigned int	msix_enabled:1;
 	unsigned int	ari_enabled:1;	/* ARI forwarding */
 	unsigned int	is_managed:1;
 	unsigned int	is_pcie:1;
 	pci_dev_flags_t dev_flags;
 	atomic_t	enable_cnt;	/* pci_enable_device has been called */
 	u32		saved_config_space[16]; /* config space saved at suspend time */
 	struct hlist_head saved_cap_space;
 	struct bin_attribute *rom_attr; /* attribute descriptor for sysfs ROM entry */
 	int rom_attr_enabled;		/* has display of the rom attribute been enabled? */
 	struct bin_attribute *res_attr[DEVICE_COUNT_RESOURCE]; /* sysfs file for resources */
 	struct bin_attribute *res_attr_wc[DEVICE_COUNT_RESOURCE]; /* sysfs file for WC mapping of resources */
 #ifdef CONFIG_PCI_MSI
 	struct list_head msi_list;
 #endif
 	struct pci_vpd *vpd;
 };
 extern struct pci_dev *alloc_pci_dev(void);
 #define pci_dev_b(n) list_entry(n, struct pci_dev, bus_list)
 #define	to_pci_dev(n) container_of(n, struct pci_dev, dev)
 #define for_each_pci_dev(d) while ((d = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, d)) != NULL)
 static inline int pci_channel_offline(struct pci_dev *pdev)
 {
 	return (pdev->error_state != pci_channel_io_normal);
 }
 static inline struct pci_cap_saved_state *pci_find_saved_cap(
 	struct pci_dev *pci_dev, char cap)
 {
 	struct pci_cap_saved_state *tmp;
 	struct hlist_node *pos;
 	hlist_for_each_entry(tmp, pos, &pci_dev->saved_cap_space, next) {
 		if (tmp->cap_nr == cap)
 			return tmp;
 	}
 	return NULL;
 }
 static inline void pci_add_saved_cap(struct pci_dev *pci_dev,
 	struct pci_cap_saved_state *new_cap)
 {
 	hlist_add_head(&new_cap->next, &pci_dev->saved_cap_space);
 }
 /*
  *  For PCI devices, the region numbers are assigned this way:
  *
  *	0-5	standard PCI regions
  *	6	expansion ROM
  *	7-10	bridges: address space assigned to buses behind the bridge
  */
 #define PCI_ROM_RESOURCE	6
 #define PCI_BRIDGE_RESOURCES	7
 #define PCI_NUM_RESOURCES	11
 #ifndef PCI_BUS_NUM_RESOURCES
 #define PCI_BUS_NUM_RESOURCES	16
 #endif
 #define PCI_REGION_FLAG_MASK	0x0fU	/* These bits of resource flags tell us the PCI region flags */
 struct pci_bus {
 	struct list_head node;		/* node in list of buses */
 	struct pci_bus	*parent;	/* parent bus this bridge is on */
 	struct list_head children;	/* list of child buses */
 	struct list_head devices;	/* list of devices on this bus */
 	struct pci_dev	*self;		/* bridge device as seen by parent */
 	struct list_head slots;		/* list of slots on this bus */
 	struct resource	*resource[PCI_BUS_NUM_RESOURCES];
 					/* address space routed to this bus */
 	struct pci_ops	*ops;		/* configuration access functions */
 	void		*sysdata;	/* hook for sys-specific extension */
 	struct proc_dir_entry *procdir;	/* directory entry in /proc/bus/pci */
 	unsigned char	number;		/* bus number */
 	unsigned char	primary;	/* number of primary bridge */
 	unsigned char	secondary;	/* number of secondary bridge */
 	unsigned char	subordinate;	/* max number of subordinate buses */
 	char		name[48];
 	unsigned short  bridge_ctl;	/* manage NO_ISA/FBB/et al behaviors */
 	pci_bus_flags_t bus_flags;	/* Inherited by child busses */
 	struct device		*bridge;
 	struct device		dev;
 	struct bin_attribute	*legacy_io; /* legacy I/O for this bus */
 	struct bin_attribute	*legacy_mem; /* legacy mem */
 	unsigned int		is_added:1;
 };
 #define pci_bus_b(n)	list_entry(n, struct pci_bus, node)
 #define to_pci_bus(n)	container_of(n, struct pci_bus, dev)
 /*
  * Error values that may be returned by PCI functions.
  */
 #define PCIBIOS_SUCCESSFUL		0x00
 #define PCIBIOS_FUNC_NOT_SUPPORTED	0x81
 #define PCIBIOS_BAD_VENDOR_ID		0x83
 #define PCIBIOS_DEVICE_NOT_FOUND	0x86
 #define PCIBIOS_BAD_REGISTER_NUMBER	0x87
 #define PCIBIOS_SET_FAILED		0x88
 #define PCIBIOS_BUFFER_TOO_SMALL	0x89
 /* Low-level architecture-dependent routines */
 struct pci_ops {
 	int (*read)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *val);
 	int (*write)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 val);
 };
 /*
  * ACPI needs to be able to access PCI config space before we've done a
  * PCI bus scan and created pci_bus structures.
  */
 extern int raw_pci_read(unsigned int domain, unsigned int bus,
 			unsigned int devfn, int reg, int len, u32 *val);
 extern int raw_pci_write(unsigned int domain, unsigned int bus,
 			unsigned int devfn, int reg, int len, u32 val);
 struct pci_bus_region {
 	resource_size_t start;
 	resource_size_t end;
 };
 struct pci_dynids {
 	spinlock_t lock;            /* protects list, index */
 	struct list_head list;      /* for IDs added at runtime */
 };
 /* ---------------------------------------------------------------- */
 /** PCI Error Recovery System (PCI-ERS).  If a PCI device driver provides
  *  a set of callbacks in struct pci_error_handlers, then that device driver
  *  will be notified of PCI bus errors, and will be driven to recovery
  *  when an error occurs.
  */
 typedef unsigned int __bitwise pci_ers_result_t;
 enum pci_ers_result {
 	/* no result/none/not supported in device driver */
 	PCI_ERS_RESULT_NONE = (__force pci_ers_result_t) 1,
 	/* Device driver can recover without slot reset */
 	PCI_ERS_RESULT_CAN_RECOVER = (__force pci_ers_result_t) 2,
 	/* Device driver wants slot to be reset. */
 	PCI_ERS_RESULT_NEED_RESET = (__force pci_ers_result_t) 3,
 	/* Device has completely failed, is unrecoverable */
 	PCI_ERS_RESULT_DISCONNECT = (__force pci_ers_result_t) 4,
 	/* Device driver is fully recovered and operational */
 	PCI_ERS_RESULT_RECOVERED = (__force pci_ers_result_t) 5,
 };
 /* PCI bus error event callbacks */
 struct pci_error_handlers {
 	/* PCI bus error detected on this device */
 	pci_ers_result_t (*error_detected)(struct pci_dev *dev,
 					   enum pci_channel_state error);
 	/* MMIO has been re-enabled, but not DMA */
 	pci_ers_result_t (*mmio_enabled)(struct pci_dev *dev);
 	/* PCI Express link has been reset */
 	pci_ers_result_t (*link_reset)(struct pci_dev *dev);
 	/* PCI slot has been reset */
 	pci_ers_result_t (*slot_reset)(struct pci_dev *dev);
 	/* Device driver may resume normal operations */
 	void (*resume)(struct pci_dev *dev);
 };
 /* ---------------------------------------------------------------- */
 struct module;
 struct pci_driver {
 	struct list_head node;
 	char *name;
 	const struct pci_device_id *id_table;	/* must be non-NULL for probe to be called */
 	int  (*probe)  (struct pci_dev *dev, const struct pci_device_id *id);	/* New device inserted */
 	void (*remove) (struct pci_dev *dev);	/* Device removed (NULL if not a hot-plug capable driver) */
 	int  (*suspend) (struct pci_dev *dev, pm_message_t state);	/* Device suspended */
 	int  (*suspend_late) (struct pci_dev *dev, pm_message_t state);
 	int  (*resume_early) (struct pci_dev *dev);
 	int  (*resume) (struct pci_dev *dev);	                /* Device woken up */
 	void (*shutdown) (struct pci_dev *dev);
-	struct pm_ext_ops *pm;
 	struct pci_error_handlers *err_handler;
 	struct device_driver	driver;
 	struct pci_dynids dynids;
 };
 #define	to_pci_driver(drv) container_of(drv, struct pci_driver, driver)
 /**
  * DEFINE_PCI_DEVICE_TABLE - macro used to describe a pci device table
  * @_table: device table name
  *
  * This macro is used to create a struct pci_device_id array (a device table)
  * in a generic manner.
  */
 #define DEFINE_PCI_DEVICE_TABLE(_table) \
 	const struct pci_device_id _table[] __devinitconst
 /**
  * PCI_DEVICE - macro used to describe a specific pci device
  * @vend: the 16 bit PCI Vendor ID
  * @dev: the 16 bit PCI Device ID
  *
  * This macro is used to create a struct pci_device_id that matches a
  * specific device.  The subvendor and subdevice fields will be set to
  * PCI_ANY_ID.
  */
 #define PCI_DEVICE(vend,dev) \
 	.vendor = (vend), .device = (dev), \
 	.subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
 /**
  * PCI_DEVICE_CLASS - macro used to describe a specific pci device class
  * @dev_class: the class, subclass, prog-if triple for this device
  * @dev_class_mask: the class mask for this device
  *
  * This macro is used to create a struct pci_device_id that matches a
  * specific PCI class.  The vendor, device, subvendor, and subdevice
  * fields will be set to PCI_ANY_ID.
  */
 #define PCI_DEVICE_CLASS(dev_class,dev_class_mask) \
 	.class = (dev_class), .class_mask = (dev_class_mask), \
 	.vendor = PCI_ANY_ID, .device = PCI_ANY_ID, \
 	.subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
 /**
  * PCI_VDEVICE - macro used to describe a specific pci device in short form
  * @vendor: the vendor name
  * @device: the 16 bit PCI Device ID
  *
  * This macro is used to create a struct pci_device_id that matches a
  * specific PCI device.  The subvendor, and subdevice fields will be set
  * to PCI_ANY_ID. The macro allows the next field to follow as the device
  * private data.
  */
 #define PCI_VDEVICE(vendor, device)		\
 	PCI_VENDOR_ID_##vendor, (device),	\
 	PCI_ANY_ID, PCI_ANY_ID, 0, 0
 /* these external functions are only available when PCI support is enabled */
 #ifdef CONFIG_PCI
 extern struct bus_type pci_bus_type;
 /* Do NOT directly access these two variables, unless you are arch specific pci
  * code, or pci core code. */
 extern struct list_head pci_root_buses;	/* list of all known PCI buses */
 /* Some device drivers need know if pci is initiated */
 extern int no_pci_devices(void);
 void pcibios_fixup_bus(struct pci_bus *);
 int __must_check pcibios_enable_device(struct pci_dev *, int mask);
 char *pcibios_setup(char *str);
 /* Used only when drivers/pci/setup.c is used */
 void pcibios_align_resource(void *, struct resource *, resource_size_t,
 				resource_size_t);
 void pcibios_update_irq(struct pci_dev *, int irq);
 /* Generic PCI functions used internally */
 extern struct pci_bus *pci_find_bus(int domain, int busnr);
 void pci_bus_add_devices(struct pci_bus *bus);
 struct pci_bus *pci_scan_bus_parented(struct device *parent, int bus,
 				      struct pci_ops *ops, void *sysdata);
 static inline struct pci_bus * __devinit pci_scan_bus(int bus, struct pci_ops *ops,
 					   void *sysdata)
 {
 	struct pci_bus *root_bus;
 	root_bus = pci_scan_bus_parented(NULL, bus, ops, sysdata);
 	if (root_bus)
 		pci_bus_add_devices(root_bus);
 	return root_bus;
 }
 struct pci_bus *pci_create_bus(struct device *parent, int bus,
 			       struct pci_ops *ops, void *sysdata);
 struct pci_bus *pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev,
 				int busnr);
 struct pci_slot *pci_create_slot(struct pci_bus *parent, int slot_nr,
 				 const char *name,
 				 struct hotplug_slot *hotplug);
 void pci_destroy_slot(struct pci_slot *slot);
 void pci_renumber_slot(struct pci_slot *slot, int slot_nr);
 int pci_scan_slot(struct pci_bus *bus, int devfn);
 struct pci_dev *pci_scan_single_device(struct pci_bus *bus, int devfn);
 void pci_device_add(struct pci_dev *dev, struct pci_bus *bus);
 unsigned int pci_scan_child_bus(struct pci_bus *bus);
 int __must_check pci_bus_add_device(struct pci_dev *dev);
 void pci_read_bridge_bases(struct pci_bus *child);
 struct resource *pci_find_parent_resource(const struct pci_dev *dev,
 					  struct resource *res);
 int pci_get_interrupt_pin(struct pci_dev *dev, struct pci_dev **bridge);
 extern struct pci_dev *pci_dev_get(struct pci_dev *dev);
 extern void pci_dev_put(struct pci_dev *dev);
 extern void pci_remove_bus(struct pci_bus *b);
 extern void pci_remove_bus_device(struct pci_dev *dev);
 extern void pci_stop_bus_device(struct pci_dev *dev);
 void pci_setup_cardbus(struct pci_bus *bus);
 extern void pci_sort_breadthfirst(void);
 /* Generic PCI functions exported to card drivers */
 #ifdef CONFIG_PCI_LEGACY
 struct pci_dev __deprecated *pci_find_device(unsigned int vendor,
 					     unsigned int device,
 					     struct pci_dev *from);
 struct pci_dev __deprecated *pci_find_slot(unsigned int bus,
 					   unsigned int devfn);
 #endif /* CONFIG_PCI_LEGACY */
 enum pci_lost_interrupt_reason {
 	PCI_LOST_IRQ_NO_INFORMATION = 0,
 	PCI_LOST_IRQ_DISABLE_MSI,
 	PCI_LOST_IRQ_DISABLE_MSIX,
 	PCI_LOST_IRQ_DISABLE_ACPI,
 };
 enum pci_lost_interrupt_reason pci_lost_interrupt(struct pci_dev *dev);
 int pci_find_capability(struct pci_dev *dev, int cap);
 int pci_find_next_capability(struct pci_dev *dev, u8 pos, int cap);
 int pci_find_ext_capability(struct pci_dev *dev, int cap);
 int pci_find_ht_capability(struct pci_dev *dev, int ht_cap);
 int pci_find_next_ht_capability(struct pci_dev *dev, int pos, int ht_cap);
 struct pci_bus *pci_find_next_bus(const struct pci_bus *from);
 struct pci_dev *pci_get_device(unsigned int vendor, unsigned int device,
 				struct pci_dev *from);
 struct pci_dev *pci_get_subsys(unsigned int vendor, unsigned int device,
 				unsigned int ss_vendor, unsigned int ss_device,
 				struct pci_dev *from);
 struct pci_dev *pci_get_slot(struct pci_bus *bus, unsigned int devfn);
 struct pci_dev *pci_get_bus_and_slot(unsigned int bus, unsigned int devfn);
 struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from);
 int pci_dev_present(const struct pci_device_id *ids);
 int pci_bus_read_config_byte(struct pci_bus *bus, unsigned int devfn,
 			     int where, u8 *val);
 int pci_bus_read_config_word(struct pci_bus *bus, unsigned int devfn,
 			     int where, u16 *val);
 int pci_bus_read_config_dword(struct pci_bus *bus, unsigned int devfn,
 			      int where, u32 *val);
 int pci_bus_write_config_byte(struct pci_bus *bus, unsigned int devfn,
 			      int where, u8 val);
 int pci_bus_write_config_word(struct pci_bus *bus, unsigned int devfn,
 			      int where, u16 val);
 int pci_bus_write_config_dword(struct pci_bus *bus, unsigned int devfn,
 			       int where, u32 val);
 static inline int pci_read_config_byte(struct pci_dev *dev, int where, u8 *val)
 {
 	return pci_bus_read_config_byte(dev->bus, dev->devfn, where, val);
 }
 static inline int pci_read_config_word(struct pci_dev *dev, int where, u16 *val)
 {
 	return pci_bus_read_config_word(dev->bus, dev->devfn, where, val);
 }
 static inline int pci_read_config_dword(struct pci_dev *dev, int where,
 					u32 *val)
 {
 	return pci_bus_read_config_dword(dev->bus, dev->devfn, where, val);
 }
 static inline int pci_write_config_byte(struct pci_dev *dev, int where, u8 val)
 {
 	return pci_bus_write_config_byte(dev->bus, dev->devfn, where, val);
 }
 static inline int pci_write_config_word(struct pci_dev *dev, int where, u16 val)
 {
 	return pci_bus_write_config_word(dev->bus, dev->devfn, where, val);
 }
 static inline int pci_write_config_dword(struct pci_dev *dev, int where,
 					 u32 val)
 {
 	return pci_bus_write_config_dword(dev->bus, dev->devfn, where, val);
 }
 int __must_check pci_enable_device(struct pci_dev *dev);
 int __must_check pci_enable_device_io(struct pci_dev *dev);
 int __must_check pci_enable_device_mem(struct pci_dev *dev);
 int __must_check pci_reenable_device(struct pci_dev *);
 int __must_check pcim_enable_device(struct pci_dev *pdev);
 void pcim_pin_device(struct pci_dev *pdev);
 static inline int pci_is_managed(struct pci_dev *pdev)
 {
 	return pdev->is_managed;
 }
 void pci_disable_device(struct pci_dev *dev);
 void pci_set_master(struct pci_dev *dev);
 int pci_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state state);
 #define HAVE_PCI_SET_MWI
 int __must_check pci_set_mwi(struct pci_dev *dev);
 int pci_try_set_mwi(struct pci_dev *dev);
 void pci_clear_mwi(struct pci_dev *dev);
 void pci_intx(struct pci_dev *dev, int enable);
 void pci_msi_off(struct pci_dev *dev);
 int pci_set_dma_mask(struct pci_dev *dev, u64 mask);
 int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask);
 int pci_set_dma_max_seg_size(struct pci_dev *dev, unsigned int size);
 int pci_set_dma_seg_boundary(struct pci_dev *dev, unsigned long mask);
 int pcix_get_max_mmrbc(struct pci_dev *dev);
 int pcix_get_mmrbc(struct pci_dev *dev);
 int pcix_set_mmrbc(struct pci_dev *dev, int mmrbc);
 int pcie_get_readrq(struct pci_dev *dev);
 int pcie_set_readrq(struct pci_dev *dev, int rq);
 int pci_reset_function(struct pci_dev *dev);
 int pci_execute_reset_function(struct pci_dev *dev);
 void pci_update_resource(struct pci_dev *dev, struct resource *res, int resno);
 int __must_check pci_assign_resource(struct pci_dev *dev, int i);
 int pci_select_bars(struct pci_dev *dev, unsigned long flags);
 /* ROM control related routines */
 int pci_enable_rom(struct pci_dev *pdev);
 void pci_disable_rom(struct pci_dev *pdev);
 void __iomem __must_check *pci_map_rom(struct pci_dev *pdev, size_t *size);
 void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom);
 size_t pci_get_rom_size(void __iomem *rom, size_t size);
 /* Power management related routines */
 int pci_save_state(struct pci_dev *dev);
 int pci_restore_state(struct pci_dev *dev);
 int pci_set_power_state(struct pci_dev *dev, pci_power_t state);
 pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state);
 bool pci_pme_capable(struct pci_dev *dev, pci_power_t state);
 void pci_pme_active(struct pci_dev *dev, bool enable);
 int pci_enable_wake(struct pci_dev *dev, pci_power_t state, int enable);
 int pci_wake_from_d3(struct pci_dev *dev, bool enable);
 pci_power_t pci_target_state(struct pci_dev *dev);
 int pci_prepare_to_sleep(struct pci_dev *dev);
 int pci_back_from_sleep(struct pci_dev *dev);
 /* Functions for PCI Hotplug drivers to use */
 int pci_bus_find_capability(struct pci_bus *bus, unsigned int devfn, int cap);
 /* Helper functions for low-level code (drivers/pci/setup-[bus,res].c) */
 void pci_bus_assign_resources(struct pci_bus *bus);
 void pci_bus_size_bridges(struct pci_bus *bus);
 int pci_claim_resource(struct pci_dev *, int);
 void pci_assign_unassigned_resources(void);
 void pdev_enable_device(struct pci_dev *);
 void pdev_sort_resources(struct pci_dev *, struct resource_list *);
 int pci_enable_resources(struct pci_dev *, int mask);
 void pci_fixup_irqs(u8 (*)(struct pci_dev *, u8 *),
 		    int (*)(struct pci_dev *, u8, u8));
 #define HAVE_PCI_REQ_REGIONS	2
 int __must_check pci_request_regions(struct pci_dev *, const char *);
 void pci_release_regions(struct pci_dev *);
 int __must_check pci_request_region(struct pci_dev *, int, const char *);
 void pci_release_region(struct pci_dev *, int);
 int pci_request_selected_regions(struct pci_dev *, int, const char *);
 void pci_release_selected_regions(struct pci_dev *, int);
 /* drivers/pci/bus.c */
 int __must_check pci_bus_alloc_resource(struct pci_bus *bus,
 			struct resource *res, resource_size_t size,
 			resource_size_t align, resource_size_t min,
 			unsigned int type_mask,
 			void (*alignf)(void *, struct resource *,
 				resource_size_t, resource_size_t),
 			void *alignf_data);
 void pci_enable_bridges(struct pci_bus *bus);
 /* Proper probing supporting hot-pluggable devices */
 int __must_check __pci_register_driver(struct pci_driver *, struct module *,
 				       const char *mod_name);
 /*
  * pci_register_driver must be a macro so that KBUILD_MODNAME can be expanded
  */
 #define pci_register_driver(driver)		\
 	__pci_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
 void pci_unregister_driver(struct pci_driver *dev);
 void pci_remove_behind_bridge(struct pci_dev *dev);
 struct pci_driver *pci_dev_driver(const struct pci_dev *dev);
 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
 					 struct pci_dev *dev);
 int pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max,
 		    int pass);
 void pci_walk_bus(struct pci_bus *top, void (*cb)(struct pci_dev *, void *),
 		  void *userdata);
 int pci_cfg_space_size_ext(struct pci_dev *dev);
 int pci_cfg_space_size(struct pci_dev *dev);
 unsigned char pci_bus_max_busnr(struct pci_bus *bus);
 /* kmem_cache style wrapper around pci_alloc_consistent() */
 #include <linux/dmapool.h>
 #define	pci_pool dma_pool
 #define pci_pool_create(name, pdev, size, align, allocation) \
 		dma_pool_create(name, &pdev->dev, size, align, allocation)
 #define	pci_pool_destroy(pool) dma_pool_destroy(pool)
 #define	pci_pool_alloc(pool, flags, handle) dma_pool_alloc(pool, flags, handle)
 #define	pci_pool_free(pool, vaddr, addr) dma_pool_free(pool, vaddr, addr)
 enum pci_dma_burst_strategy {
 	PCI_DMA_BURST_INFINITY,	/* make bursts as large as possible,
 				   strategy_parameter is N/A */
 	PCI_DMA_BURST_BOUNDARY, /* disconnect at every strategy_parameter
 				   byte boundaries */
 	PCI_DMA_BURST_MULTIPLE, /* disconnect at some multiple of
 				   strategy_parameter byte boundaries */
 };
 struct msix_entry {
 	u32	vector;	/* kernel uses to write allocated vector */
 	u16	entry;	/* driver uses to specify entry, OS writes */
 };
 #ifndef CONFIG_PCI_MSI
 static inline int pci_enable_msi(struct pci_dev *dev)
 {
 	return -1;
 }
 static inline void pci_msi_shutdown(struct pci_dev *dev)
 { }
 static inline void pci_disable_msi(struct pci_dev *dev)
 { }
 static inline int pci_enable_msix(struct pci_dev *dev,
 				  struct msix_entry *entries, int nvec)
 {
 	return -1;
 }
 static inline void pci_msix_shutdown(struct pci_dev *dev)
 { }
 static inline void pci_disable_msix(struct pci_dev *dev)
 { }
 static inline void msi_remove_pci_irq_vectors(struct pci_dev *dev)
 { }
 static inline void pci_restore_msi_state(struct pci_dev *dev)
 { }
 #else
 extern int pci_enable_msi(struct pci_dev *dev);
 extern void pci_msi_shutdown(struct pci_dev *dev);
 extern void pci_disable_msi(struct pci_dev *dev);
 extern int pci_enable_msix(struct pci_dev *dev,
 	struct msix_entry *entries, int nvec);
 extern void pci_msix_shutdown(struct pci_dev *dev);
 extern void pci_disable_msix(struct pci_dev *dev);
 extern void msi_remove_pci_irq_vectors(struct pci_dev *dev);
 extern void pci_restore_msi_state(struct pci_dev *dev);
 #endif
 #ifdef CONFIG_HT_IRQ
 /* The functions a driver should call */
 int  ht_create_irq(struct pci_dev *dev, int idx);
 void ht_destroy_irq(unsigned int irq);
 #endif /* CONFIG_HT_IRQ */
 extern void pci_block_user_cfg_access(struct pci_dev *dev);
 extern void pci_unblock_user_cfg_access(struct pci_dev *dev);
 /*
  * PCI domain support.  Sometimes called PCI segment (eg by ACPI),
  * a PCI domain is defined to be a set of PCI busses which share
  * configuration space.
  */
 #ifdef CONFIG_PCI_DOMAINS
 extern int pci_domains_supported;
 #else
 enum { pci_domains_supported = 0 };
 static inline int pci_domain_nr(struct pci_bus *bus)
 {
 	return 0;
 }
 static inline int pci_proc_domain(struct pci_bus *bus)
 {
 	return 0;
 }
 #endif /* CONFIG_PCI_DOMAINS */
 #else /* CONFIG_PCI is not enabled */
 /*
  *  If the system does not have PCI, clearly these return errors.  Define
  *  these as simple inline functions to avoid hair in drivers.
  */
 #define _PCI_NOP(o, s, t) \
 	static inline int pci_##o##_config_##s(struct pci_dev *dev, \
 						int where, t val) \
 		{ return PCIBIOS_FUNC_NOT_SUPPORTED; }
 #define _PCI_NOP_ALL(o, x)	_PCI_NOP(o, byte, u8 x) \
 				_PCI_NOP(o, word, u16 x) \
 				_PCI_NOP(o, dword, u32 x)
 _PCI_NOP_ALL(read, *)
 _PCI_NOP_ALL(write,)
 static inline struct pci_dev *pci_find_device(unsigned int vendor,
 					      unsigned int device,
 					      struct pci_dev *from)
 {
 	return NULL;
 }
 static inline struct pci_dev *pci_find_slot(unsigned int bus,
 					    unsigned int devfn)
 {
 	return NULL;
 }
 static inline struct pci_dev *pci_get_device(unsigned int vendor,
 					     unsigned int device,
 					     struct pci_dev *from)
 {
 	return NULL;
 }
 static inline struct pci_dev *pci_get_subsys(unsigned int vendor,
 					     unsigned int device,
 					     unsigned int ss_vendor,
 					     unsigned int ss_device,
 					     struct pci_dev *from)
 {
 	return NULL;
 }
 static inline struct pci_dev *pci_get_class(unsigned int class,
 					    struct pci_dev *from)
 {
 	return NULL;
 }
 #define pci_dev_present(ids)	(0)
 #define no_pci_devices()	(1)
 #define pci_dev_put(dev)	do { } while (0)
 static inline void pci_set_master(struct pci_dev *dev)
 { }
 static inline int pci_enable_device(struct pci_dev *dev)
 {
 	return -EIO;
 }
 static inline void pci_disable_device(struct pci_dev *dev)
 { }
 static inline int pci_set_dma_mask(struct pci_dev *dev, u64 mask)
 {
 	return -EIO;
 }
 static inline int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask)
 {
 	return -EIO;
 }
 static inline int pci_set_dma_max_seg_size(struct pci_dev *dev,
 					unsigned int size)
 {
 	return -EIO;
 }
 static inline int pci_set_dma_seg_boundary(struct pci_dev *dev,
 					unsigned long mask)
 {
 	return -EIO;
 }
 static inline int pci_assign_resource(struct pci_dev *dev, int i)
 {
 	return -EBUSY;
 }
 static inline int __pci_register_driver(struct pci_driver *drv,
 					struct module *owner)
 {
 	return 0;
 }
 static inline int pci_register_driver(struct pci_driver *drv)
 {
 	return 0;
 }
 static inline void pci_unregister_driver(struct pci_driver *drv)
 { }
 static inline int pci_find_capability(struct pci_dev *dev, int cap)
 {
 	return 0;
 }
 static inline int pci_find_next_capability(struct pci_dev *dev, u8 post,
 					   int cap)
 {
 	return 0;
 }
 static inline int pci_find_ext_capability(struct pci_dev *dev, int cap)
 {
 	return 0;
 }
 /* Power management related routines */
 static inline int pci_save_state(struct pci_dev *dev)
 {
 	return 0;
 }
 static inline int pci_restore_state(struct pci_dev *dev)
 {
 	return 0;
 }
 static inline int pci_set_power_state(struct pci_dev *dev, pci_power_t state)
 {
 	return 0;
 }
 static inline pci_power_t pci_choose_state(struct pci_dev *dev,
 					   pm_message_t state)
 {
 	return PCI_D0;
 }
 static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state,
 				  int enable)
 {
 	return 0;
 }
 static inline int pci_request_regions(struct pci_dev *dev, const char *res_name)
 {
 	return -EIO;
 }
 static inline void pci_release_regions(struct pci_dev *dev)
 { }
 #define pci_dma_burst_advice(pdev, strat, strategy_parameter) do { } while (0)
 static inline void pci_block_user_cfg_access(struct pci_dev *dev)
 { }
 static inline void pci_unblock_user_cfg_access(struct pci_dev *dev)
 { }
 static inline struct pci_bus *pci_find_next_bus(const struct pci_bus *from)
 { return NULL; }
 static inline struct pci_dev *pci_get_slot(struct pci_bus *bus,
 						unsigned int devfn)
 { return NULL; }
 static inline struct pci_dev *pci_get_bus_and_slot(unsigned int bus,
 						unsigned int devfn)
 { return NULL; }
 #endif /* CONFIG_PCI */
 /* Include architecture-dependent settings and functions */
 #include <asm/pci.h>
 /* these helpers provide future and backwards compatibility
  * for accessing popular PCI BAR info */
 #define pci_resource_start(dev, bar)	((dev)->resource[(bar)].start)
 #define pci_resource_end(dev, bar)	((dev)->resource[(bar)].end)
 #define pci_resource_flags(dev, bar)	((dev)->resource[(bar)].flags)
 #define pci_resource_len(dev,bar) \
 	((pci_resource_start((dev), (bar)) == 0 &&	\
 	  pci_resource_end((dev), (bar)) ==		\
 	  pci_resource_start((dev), (bar))) ? 0 :	\
 							\
 	 (pci_resource_end((dev), (bar)) -		\
 	  pci_resource_start((dev), (bar)) + 1))
 /* Similar to the helpers above, these manipulate per-pci_dev
  * driver-specific data.  They are really just a wrapper around
  * the generic device structure functions of these calls.
  */
 static inline void *pci_get_drvdata(struct pci_dev *pdev)
 {
 	return dev_get_drvdata(&pdev->dev);
 }
 static inline void pci_set_drvdata(struct pci_dev *pdev, void *data)
 {
 	dev_set_drvdata(&pdev->dev, data);
 }
 /* If you want to know what to call your pci_dev, ask this function.
  * Again, it's a wrapper around the generic device.
  */
 static inline const char *pci_name(struct pci_dev *pdev)
 {
 	return dev_name(&pdev->dev);
 }
 /* Some archs don't want to expose struct resource to userland as-is
  * in sysfs and /proc
  */
 #ifndef HAVE_ARCH_PCI_RESOURCE_TO_USER
 static inline void pci_resource_to_user(const struct pci_dev *dev, int bar,
 		const struct resource *rsrc, resource_size_t *start,
 		resource_size_t *end)
 {
 	*start = rsrc->start;
 	*end = rsrc->end;
 }
 #endif /* HAVE_ARCH_PCI_RESOURCE_TO_USER */
 /*
  *  The world is not perfect and supplies us with broken PCI devices.
  *  For at least a part of these bugs we need a work-around, so both
  *  generic (drivers/pci/quirks.c) and per-architecture code can define
  *  fixup hooks to be called for particular buggy devices.
  */
 struct pci_fixup {
 	u16 vendor, device;	/* You can use PCI_ANY_ID here of course */
 	void (*hook)(struct pci_dev *dev);
 };
 enum pci_fixup_pass {
 	pci_fixup_early,	/* Before probing BARs */
 	pci_fixup_header,	/* After reading configuration header */
 	pci_fixup_final,	/* Final phase of device fixups */
 	pci_fixup_enable,	/* pci_enable_device() time */
 	pci_fixup_resume,	/* pci_device_resume() */
 	pci_fixup_suspend,	/* pci_device_suspend */
 	pci_fixup_resume_early, /* pci_device_resume_early() */
 };
 /* Anonymous variables would be nice... */
 #define DECLARE_PCI_FIXUP_SECTION(section, name, vendor, device, hook)	\
 	static const struct pci_fixup __pci_fixup_##name __used		\
 	__attribute__((__section__(#section))) = { vendor, device, hook };
 #define DECLARE_PCI_FIXUP_EARLY(vendor, device, hook)			\
 	DECLARE_PCI_FIXUP_SECTION(.pci_fixup_early,			\
 			vendor##device##hook, vendor, device, hook)
 #define DECLARE_PCI_FIXUP_HEADER(vendor, device, hook)			\
 	DECLARE_PCI_FIXUP_SECTION(.pci_fixup_header,			\
 			vendor##device##hook, vendor, device, hook)
 #define DECLARE_PCI_FIXUP_FINAL(vendor, device, hook)			\
 	DECLARE_PCI_FIXUP_SECTION(.pci_fixup_final,			\
 			vendor##device##hook, vendor, device, hook)
 #define DECLARE_PCI_FIXUP_ENABLE(vendor, device, hook)			\
 	DECLARE_PCI_FIXUP_SECTION(.pci_fixup_enable,			\
 			vendor##device##hook, vendor, device, hook)
 #define DECLARE_PCI_FIXUP_RESUME(vendor, device, hook)			\
 	DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume,			\
 			resume##vendor##device##hook, vendor, device, hook)
 #define DECLARE_PCI_FIXUP_RESUME_EARLY(vendor, device, hook)		\
 	DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume_early,		\
 			resume_early##vendor##device##hook, vendor, device, hook)
 #define DECLARE_PCI_FIXUP_SUSPEND(vendor, device, hook)			\
 	DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend,			\
 			suspend##vendor##device##hook, vendor, device, hook)
 void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev);
 void __iomem *pcim_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen);
 void pcim_iounmap(struct pci_dev *pdev, void __iomem *addr);
 void __iomem * const *pcim_iomap_table(struct pci_dev *pdev);
 int pcim_iomap_regions(struct pci_dev *pdev, u16 mask, const char *name);
 int pcim_iomap_regions_request_all(struct pci_dev *pdev, u16 mask,
 				   const char *name);
 void pcim_iounmap_regions(struct pci_dev *pdev, u16 mask);
 extern int pci_pci_problems;
 #define PCIPCI_FAIL		1	/* No PCI PCI DMA */
 #define PCIPCI_TRITON		2
 #define PCIPCI_NATOMA		4
 #define PCIPCI_VIAETBF		8
 #define PCIPCI_VSFX		16
 #define PCIPCI_ALIMAGIK		32	/* Need low latency setting */
 #define PCIAGP_FAIL		64	/* No PCI to AGP DMA */
 extern unsigned long pci_cardbus_io_size;
 extern unsigned long pci_cardbus_mem_size;
 int pcibios_add_platform_entries(struct pci_dev *dev);
 void pcibios_disable_device(struct pci_dev *dev);
 int pcibios_set_pcie_reset_state(struct pci_dev *dev,
 				 enum pcie_reset_state state);
 #ifdef CONFIG_PCI_MMCONFIG
 extern void __init pci_mmcfg_early_init(void);
 extern void __init pci_mmcfg_late_init(void);
 #else
 static inline void pci_mmcfg_early_init(void) { }
 static inline void pci_mmcfg_late_init(void) { }
 #endif
 #ifdef CONFIG_HAS_IOMEM
 static inline void __iomem *pci_ioremap_bar(struct pci_dev *pdev, int bar)
 {
 	/*
 	 * Make sure the BAR is actually a memory resource, not an IO resource
 	 */
 	if (!(pci_resource_flags(pdev, bar) & IORESOURCE_MEM)) {
 		WARN_ON(1);
 		return NULL;
 	}
 	return ioremap_nocache(pci_resource_start(pdev, bar),
 				     pci_resource_len(pdev, bar));
 }
 #endif
 #endif /* __KERNEL__ */
 #endif /* LINUX_PCI_H */

include/linux/platform_device.h

Diff comments View file @ adf0949

 /*
  * platform_device.h - generic, centralized driver model
  *
  * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
  *
  * This file is released under the GPLv2
  *
  * See Documentation/driver-model/ for more information.
  */
 #ifndef _PLATFORM_DEVICE_H_
 #define _PLATFORM_DEVICE_H_
 #include <linux/device.h>
 struct platform_device {
 	const char	* name;
 	int		id;
 	struct device	dev;
 	u32		num_resources;
 	struct resource	* resource;
 };
 #define to_platform_device(x) container_of((x), struct platform_device, dev)
 extern int platform_device_register(struct platform_device *);
 extern void platform_device_unregister(struct platform_device *);
 extern struct bus_type platform_bus_type;
 extern struct device platform_bus;
 extern struct resource *platform_get_resource(struct platform_device *, unsigned int, unsigned int);
 extern int platform_get_irq(struct platform_device *, unsigned int);
 extern struct resource *platform_get_resource_byname(struct platform_device *, unsigned int, char *);
 extern int platform_get_irq_byname(struct platform_device *, char *);
 extern int platform_add_devices(struct platform_device **, int);
 extern struct platform_device *platform_device_register_simple(const char *, int id,
 					struct resource *, unsigned int);
 extern struct platform_device *platform_device_register_data(struct device *,
 		const char *, int, const void *, size_t);
 extern struct platform_device *platform_device_alloc(const char *name, int id);
 extern int platform_device_add_resources(struct platform_device *pdev, struct resource *res, unsigned int num);
 extern int platform_device_add_data(struct platform_device *pdev, const void *data, size_t size);
 extern int platform_device_add(struct platform_device *pdev);
 extern void platform_device_del(struct platform_device *pdev);
 extern void platform_device_put(struct platform_device *pdev);
 struct platform_driver {
 	int (*probe)(struct platform_device *);
 	int (*remove)(struct platform_device *);
 	void (*shutdown)(struct platform_device *);
 	int (*suspend)(struct platform_device *, pm_message_t state);
 	int (*suspend_late)(struct platform_device *, pm_message_t state);
 	int (*resume_early)(struct platform_device *);
 	int (*resume)(struct platform_device *);
-	struct pm_ext_ops *pm;
 	struct device_driver driver;
 };
 extern int platform_driver_register(struct platform_driver *);
 extern void platform_driver_unregister(struct platform_driver *);
 /* non-hotpluggable platform devices may use this so that probe() and
  * its support may live in __init sections, conserving runtime memory.
  */
 extern int platform_driver_probe(struct platform_driver *driver,
 		int (*probe)(struct platform_device *));
 #define platform_get_drvdata(_dev)	dev_get_drvdata(&(_dev)->dev)
 #define platform_set_drvdata(_dev,data)	dev_set_drvdata(&(_dev)->dev, (data))
 #endif /* _PLATFORM_DEVICE_H_ */

include/linux/pm.h

Diff comments View file @ adf0949

 /*
  *  pm.h - Power management interface
  *
  *  Copyright (C) 2000 Andrew Henroid
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 #ifndef _LINUX_PM_H
 #define _LINUX_PM_H
 #include <linux/list.h>
 /*
  * Callbacks for platform drivers to implement.
  */
 extern void (*pm_idle)(void);
 extern void (*pm_power_off)(void);
 extern void (*pm_power_off_prepare)(void);
 /*
  * Device power management
  */
 struct device;
 typedef struct pm_message {
 	int event;
 } pm_message_t;
 /**
- * struct pm_ops - device PM callbacks
+ * struct dev_pm_ops - device PM callbacks
  *
  * Several driver power state transitions are externally visible, affecting
  * the state of pending I/O queues and (for drivers that touch hardware)
  * interrupts, wakeups, DMA, and other hardware state.  There may also be
  * internal transitions to various low power modes, which are transparent
  * to the rest of the driver stack (such as a driver that's ON gating off
  * clocks which are not in active use).
  *
  * The externally visible transitions are handled with the help of the following
  * callbacks included in this structure:
  *
  * @prepare: Prepare the device for the upcoming transition, but do NOT change
  *	its hardware state.  Prevent new children of the device from being
  *	registered after @prepare() returns (the driver's subsystem and
  *	generally the rest of the kernel is supposed to prevent new calls to the
  *	probe method from being made too once @prepare() has succeeded).  If
  *	@prepare() detects a situation it cannot handle (e.g. registration of a
  *	child already in progress), it may return -EAGAIN, so that the PM core
  *	can execute it once again (e.g. after the new child has been registered)
  *	to recover from the race condition.  This method is executed for all
  *	kinds of suspend transitions and is followed by one of the suspend
  *	callbacks: @suspend(), @freeze(), or @poweroff().
  *	The PM core executes @prepare() for all devices before starting to
  *	execute suspend callbacks for any of them, so drivers may assume all of
  *	the other devices to be present and functional while @prepare() is being
  *	executed.  In particular, it is safe to make GFP_KERNEL memory
  *	allocations from within @prepare().  However, drivers may NOT assume
  *	anything about the availability of the user space at that time and it
  *	is not correct to request firmware from within @prepare() (it's too
  *	late to do that).  [To work around this limitation, drivers may
  *	register suspend and hibernation notifiers that are executed before the
  *	freezing of tasks.]
  *
  * @complete: Undo the changes made by @prepare().  This method is executed for
  *	all kinds of resume transitions, following one of the resume callbacks:
  *	@resume(), @thaw(), @restore().  Also called if the state transition
  *	fails before the driver's suspend callback (@suspend(), @freeze(),
  *	@poweroff()) can be executed (e.g. if the suspend callback fails for one
  *	of the other devices that the PM core has unsuccessfully attempted to
  *	suspend earlier).
  *	The PM core executes @complete() after it has executed the appropriate
  *	resume callback for all devices.
  *
  * @suspend: Executed before putting the system into a sleep state in which the
  *	contents of main memory are preserved.  Quiesce the device, put it into
  *	a low power state appropriate for the upcoming system state (such as
  *	PCI_D3hot), and enable wakeup events as appropriate.
  *
  * @resume: Executed after waking the system up from a sleep state in which the
  *	contents of main memory were preserved.  Put the device into the
  *	appropriate state, according to the information saved in memory by the
  *	preceding @suspend().  The driver starts working again, responding to
  *	hardware events and software requests.  The hardware may have gone
  *	through a power-off reset, or it may have maintained state from the
  *	previous suspend() which the driver may rely on while resuming.  On most
  *	platforms, there are no restrictions on availability of resources like
  *	clocks during @resume().
  *
  * @freeze: Hibernation-specific, executed before creating a hibernation image.
  *	Quiesce operations so that a consistent image can be created, but do NOT
  *	otherwise put the device into a low power device state and do NOT emit
  *	system wakeup events.  Save in main memory the device settings to be
  *	used by @restore() during the subsequent resume from hibernation or by
  *	the subsequent @thaw(), if the creation of the image or the restoration
  *	of main memory contents from it fails.
  *
  * @thaw: Hibernation-specific, executed after creating a hibernation image OR
  *	if the creation of the image fails.  Also executed after a failing
  *	attempt to restore the contents of main memory from such an image.
  *	Undo the changes made by the preceding @freeze(), so the device can be
  *	operated in the same way as immediately before the call to @freeze().
  *
  * @poweroff: Hibernation-specific, executed after saving a hibernation image.
  *	Quiesce the device, put it into a low power state appropriate for the
  *	upcoming system state (such as PCI_D3hot), and enable wakeup events as
  *	appropriate.
  *
  * @restore: Hibernation-specific, executed after restoring the contents of main
  *	memory from a hibernation image.  Driver starts working again,
  *	responding to hardware events and software requests.  Drivers may NOT
  *	make ANY assumptions about the hardware state right prior to @restore().
  *	On most platforms, there are no restrictions on availability of
  *	resources like clocks during @restore().
  *
- * All of the above callbacks, except for @complete(), return error codes.
- * However, the error codes returned by the resume operations, @resume(),
- * @thaw(), and @restore(), do not cause the PM core to abort the resume
- * transition during which they are returned.  The error codes returned in
- * that cases are only printed by the PM core to the system logs for debugging
- * purposes.  Still, it is recommended that drivers only return error codes
- * from their resume methods in case of an unrecoverable failure (i.e. when the
- * device being handled refuses to resume and becomes unusable) to allow us to
- * modify the PM core in the future, so that it can avoid attempting to handle
- * devices that failed to resume and their children.
- *
- * It is allowed to unregister devices while the above callbacks are being
- * executed.  However, it is not allowed to unregister a device from within any
- * of its own callbacks.
- */
-struct pm_ops {
-	int (*prepare)(struct device *dev);
-	void (*complete)(struct device *dev);
-	int (*suspend)(struct device *dev);
-	int (*resume)(struct device *dev);
-	int (*freeze)(struct device *dev);
-	int (*thaw)(struct device *dev);
-	int (*poweroff)(struct device *dev);
-	int (*restore)(struct device *dev);
-};
-/**
- * struct pm_ext_ops - extended device PM callbacks
- *
- * Some devices require certain operations related to suspend and hibernation
- * to be carried out with interrupts disabled.  Thus, 'struct pm_ext_ops' below
- * is defined, adding callbacks to be executed with interrupts disabled to
- * 'struct pm_ops'.
- *
- * The following callbacks included in 'struct pm_ext_ops' are executed with
- * the nonboot CPUs switched off and with interrupts disabled on the only
- * functional CPU.  They also are executed with the PM core list of devices
- * locked, so they must NOT unregister any devices.
- *
  * @suspend_noirq: Complete the operations of ->suspend() by carrying out any
  *	actions required for suspending the device that need interrupts to be
  *	disabled
  *
  * @resume_noirq: Prepare for the execution of ->resume() by carrying out any
  *	actions required for resuming the device that need interrupts to be
  *	disabled
  *
  * @freeze_noirq: Complete the operations of ->freeze() by carrying out any
  *	actions required for freezing the device that need interrupts to be
  *	disabled
  *
  * @thaw_noirq: Prepare for the execution of ->thaw() by carrying out any
  *	actions required for thawing the device that need interrupts to be
  *	disabled
  *
  * @poweroff_noirq: Complete the operations of ->poweroff() by carrying out any
  *	actions required for handling the device that need interrupts to be
  *	disabled
  *
  * @restore_noirq: Prepare for the execution of ->restore() by carrying out any
  *	actions required for restoring the operations of the device that need
  *	interrupts to be disabled
  *
- * All of the above callbacks return error codes, but the error codes returned
+ * All of the above callbacks, except for @complete(), return error codes.
- * by the resume operations, @resume_noirq(), @thaw_noirq(), and
+ * However, the error codes returned by the resume operations, @resume(),
- * @restore_noirq(), do not cause the PM core to abort the resume transition
+ * @thaw(), @restore(), @resume_noirq(), @thaw_noirq(), and @restore_noirq() do
- * during which they are returned.  The error codes returned in that cases are
+ * not cause the PM core to abort the resume transition during which they are
- * only printed by the PM core to the system logs for debugging purposes.
+ * returned.  The error codes returned in that cases are only printed by the PM
- * Still, as stated above, it is recommended that drivers only return error
+ * core to the system logs for debugging purposes.  Still, it is recommended
- * codes from their resume methods if the device being handled fails to resume
+ * that drivers only return error codes from their resume methods in case of an
- * and is not usable any more.
+ * unrecoverable failure (i.e. when the device being handled refuses to resume
+ * and becomes unusable) to allow us to modify the PM core in the future, so
+ * that it can avoid attempting to handle devices that failed to resume and
+ * their children.
+ *
+ * It is allowed to unregister devices while the above callbacks are being
+ * executed.  However, it is not allowed to unregister a device from within any
+ * of its own callbacks.
  */
-struct pm_ext_ops {
+struct dev_pm_ops {
-	struct pm_ops base;
+	int (*prepare)(struct device *dev);
+	void (*complete)(struct device *dev);
+	int (*suspend)(struct device *dev);
+	int (*resume)(struct device *dev);
+	int (*freeze)(struct device *dev);
+	int (*thaw)(struct device *dev);
+	int (*poweroff)(struct device *dev);
+	int (*restore)(struct device *dev);
 	int (*suspend_noirq)(struct device *dev);
 	int (*resume_noirq)(struct device *dev);
 	int (*freeze_noirq)(struct device *dev);
 	int (*thaw_noirq)(struct device *dev);
 	int (*poweroff_noirq)(struct device *dev);
 	int (*restore_noirq)(struct device *dev);
 };
 /**
  * PM_EVENT_ messages
  *
  * The following PM_EVENT_ messages are defined for the internal use of the PM
  * core, in order to provide a mechanism allowing the high level suspend and
  * hibernation code to convey the necessary information to the device PM core
  * code:
  *
  * ON		No transition.
  *
  * FREEZE 	System is going to hibernate, call ->prepare() and ->freeze()
  *		for all devices.
  *
  * SUSPEND	System is going to suspend, call ->prepare() and ->suspend()
  *		for all devices.
  *
  * HIBERNATE	Hibernation image has been saved, call ->prepare() and
  *		->poweroff() for all devices.
  *
  * QUIESCE	Contents of main memory are going to be restored from a (loaded)
  *		hibernation image, call ->prepare() and ->freeze() for all
  *		devices.
  *
  * RESUME	System is resuming, call ->resume() and ->complete() for all
  *		devices.
  *
  * THAW		Hibernation image has been created, call ->thaw() and
  *		->complete() for all devices.
  *
  * RESTORE	Contents of main memory have been restored from a hibernation
  *		image, call ->restore() and ->complete() for all devices.
  *
  * RECOVER	Creation of a hibernation image or restoration of the main
  *		memory contents from a hibernation image has failed, call
  *		->thaw() and ->complete() for all devices.
  *
  * The following PM_EVENT_ messages are defined for internal use by
  * kernel subsystems.  They are never issued by the PM core.
  *
  * USER_SUSPEND		Manual selective suspend was issued by userspace.
  *
  * USER_RESUME		Manual selective resume was issued by userspace.
  *
  * REMOTE_WAKEUP	Remote-wakeup request was received from the device.
  *
  * AUTO_SUSPEND		Automatic (device idle) runtime suspend was
  *			initiated by the subsystem.
  *
  * AUTO_RESUME		Automatic (device needed) runtime resume was
  *			requested by a driver.
  */
 #define PM_EVENT_ON		0x0000
 #define PM_EVENT_FREEZE 	0x0001
 #define PM_EVENT_SUSPEND	0x0002
 #define PM_EVENT_HIBERNATE	0x0004
 #define PM_EVENT_QUIESCE	0x0008
 #define PM_EVENT_RESUME		0x0010
 #define PM_EVENT_THAW		0x0020
 #define PM_EVENT_RESTORE	0x0040
 #define PM_EVENT_RECOVER	0x0080
 #define PM_EVENT_USER		0x0100
 #define PM_EVENT_REMOTE		0x0200
 #define PM_EVENT_AUTO		0x0400
 #define PM_EVENT_SLEEP		(PM_EVENT_SUSPEND | PM_EVENT_HIBERNATE)
 #define PM_EVENT_USER_SUSPEND	(PM_EVENT_USER | PM_EVENT_SUSPEND)
 #define PM_EVENT_USER_RESUME	(PM_EVENT_USER | PM_EVENT_RESUME)
 #define PM_EVENT_REMOTE_WAKEUP	(PM_EVENT_REMOTE | PM_EVENT_RESUME)
 #define PM_EVENT_AUTO_SUSPEND	(PM_EVENT_AUTO | PM_EVENT_SUSPEND)
 #define PM_EVENT_AUTO_RESUME	(PM_EVENT_AUTO | PM_EVENT_RESUME)
 #define PMSG_ON		((struct pm_message){ .event = PM_EVENT_ON, })
 #define PMSG_FREEZE	((struct pm_message){ .event = PM_EVENT_FREEZE, })
 #define PMSG_QUIESCE	((struct pm_message){ .event = PM_EVENT_QUIESCE, })
 #define PMSG_SUSPEND	((struct pm_message){ .event = PM_EVENT_SUSPEND, })
 #define PMSG_HIBERNATE	((struct pm_message){ .event = PM_EVENT_HIBERNATE, })
 #define PMSG_RESUME	((struct pm_message){ .event = PM_EVENT_RESUME, })
 #define PMSG_THAW	((struct pm_message){ .event = PM_EVENT_THAW, })
 #define PMSG_RESTORE	((struct pm_message){ .event = PM_EVENT_RESTORE, })
 #define PMSG_RECOVER	((struct pm_message){ .event = PM_EVENT_RECOVER, })
 #define PMSG_USER_SUSPEND	((struct pm_messge) \
 					{ .event = PM_EVENT_USER_SUSPEND, })
 #define PMSG_USER_RESUME	((struct pm_messge) \
 					{ .event = PM_EVENT_USER_RESUME, })
 #define PMSG_REMOTE_RESUME	((struct pm_messge) \
 					{ .event = PM_EVENT_REMOTE_RESUME, })
 #define PMSG_AUTO_SUSPEND	((struct pm_messge) \
 					{ .event = PM_EVENT_AUTO_SUSPEND, })
 #define PMSG_AUTO_RESUME		((struct pm_messge) \
 					{ .event = PM_EVENT_AUTO_RESUME, })
 /**
  * Device power management states
  *
  * These state labels are used internally by the PM core to indicate the current
  * status of a device with respect to the PM core operations.
  *
  * DPM_ON		Device is regarded as operational.  Set this way
  *			initially and when ->complete() is about to be called.
  *			Also set when ->prepare() fails.
  *
  * DPM_PREPARING	Device is going to be prepared for a PM transition.  Set
  *			when ->prepare() is about to be called.
  *
  * DPM_RESUMING		Device is going to be resumed.  Set when ->resume(),
  *			->thaw(), or ->restore() is about to be called.
  *
  * DPM_SUSPENDING	Device has been prepared for a power transition.  Set
  *			when ->prepare() has just succeeded.
  *
  * DPM_OFF		Device is regarded as inactive.  Set immediately after
  *			->suspend(), ->freeze(), or ->poweroff() has succeeded.
  *			Also set when ->resume()_noirq, ->thaw_noirq(), or
  *			->restore_noirq() is about to be called.
  *
  * DPM_OFF_IRQ		Device is in a "deep sleep".  Set immediately after
  *			->suspend_noirq(), ->freeze_noirq(), or
  *			->poweroff_noirq() has just succeeded.
  */
 enum dpm_state {
 	DPM_INVALID,
 	DPM_ON,
 	DPM_PREPARING,
 	DPM_RESUMING,
 	DPM_SUSPENDING,
 	DPM_OFF,
 	DPM_OFF_IRQ,
 };
 struct dev_pm_info {
 	pm_message_t		power_state;
 	unsigned		can_wakeup:1;
 	unsigned		should_wakeup:1;
 	enum dpm_state		status;		/* Owned by the PM core */
 #ifdef	CONFIG_PM_SLEEP
 	struct list_head	entry;
 #endif
 };
 /*
  * The PM_EVENT_ messages are also used by drivers implementing the legacy
  * suspend framework, based on the ->suspend() and ->resume() callbacks common
  * for suspend and hibernation transitions, according to the rules below.
  */
 /* Necessary, because several drivers use PM_EVENT_PRETHAW */
 #define PM_EVENT_PRETHAW PM_EVENT_QUIESCE
 /*
  * One transition is triggered by resume(), after a suspend() call; the
  * message is implicit:
  *
  * ON		Driver starts working again, responding to hardware events
  * 		and software requests.  The hardware may have gone through
  * 		a power-off reset, or it may have maintained state from the
  * 		previous suspend() which the driver will rely on while
  * 		resuming.  On most platforms, there are no restrictions on
  * 		availability of resources like clocks during resume().
  *
  * Other transitions are triggered by messages sent using suspend().  All
  * these transitions quiesce the driver, so that I/O queues are inactive.
  * That commonly entails turning off IRQs and DMA; there may be rules
  * about how to quiesce that are specific to the bus or the device's type.
  * (For example, network drivers mark the link state.)  Other details may
  * differ according to the message:
  *
  * SUSPEND	Quiesce, enter a low power device state appropriate for
  * 		the upcoming system state (such as PCI_D3hot), and enable
  * 		wakeup events as appropriate.
  *
  * HIBERNATE	Enter a low power device state appropriate for the hibernation
  * 		state (eg. ACPI S4) and enable wakeup events as appropriate.
  *
  * FREEZE	Quiesce operations so that a consistent image can be saved;
  * 		but do NOT otherwise enter a low power device state, and do
  * 		NOT emit system wakeup events.
  *
  * PRETHAW	Quiesce as if for FREEZE; additionally, prepare for restoring
  * 		the system from a snapshot taken after an earlier FREEZE.
  * 		Some drivers will need to reset their hardware state instead
  * 		of preserving it, to ensure that it's never mistaken for the
  * 		state which that earlier snapshot had set up.
  *
  * A minimally power-aware driver treats all messages as SUSPEND, fully
  * reinitializes its device during resume() -- whether or not it was reset
  * during the suspend/resume cycle -- and can't issue wakeup events.
  *
  * More power-aware drivers may also use low power states at runtime as
  * well as during system sleep states like PM_SUSPEND_STANDBY.  They may
  * be able to use wakeup events to exit from runtime low-power states,
  * or from system low-power states such as standby or suspend-to-RAM.
  */
 #ifdef CONFIG_PM_SLEEP
 extern void device_pm_lock(void);
 extern void device_power_up(pm_message_t state);
 extern void device_resume(pm_message_t state);
 extern void device_pm_unlock(void);
 extern int device_power_down(pm_message_t state);
 extern int device_suspend(pm_message_t state);
 extern int device_prepare_suspend(pm_message_t state);
 extern void __suspend_report_result(const char *function, void *fn, int ret);
 #define suspend_report_result(fn, ret)					\
 	do {								\
 		__suspend_report_result(__func__, fn, ret);		\
 	} while (0)
 #else /* !CONFIG_PM_SLEEP */
 static inline int device_suspend(pm_message_t state)
 {
 	return 0;
 }
 #define suspend_report_result(fn, ret)		do {} while (0)