2008-11-25 14:39:18 -07:00
|
|
|
#include <linux/pm.h>
|
2012-09-04 23:44:33 -06:00
|
|
|
#include <linux/acpi.h>
|
2008-11-25 14:39:18 -07:00
|
|
|
|
2013-01-21 07:18:00 -07:00
|
|
|
struct usb_hub_descriptor;
|
2014-03-10 02:36:40 -06:00
|
|
|
struct usb_dev_state;
|
2012-07-06 00:13:52 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Functions local to drivers/usb/core/ */
|
|
|
|
|
2008-01-30 16:21:33 -07:00
|
|
|
extern int usb_create_sysfs_dev_files(struct usb_device *dev);
|
|
|
|
extern void usb_remove_sysfs_dev_files(struct usb_device *dev);
|
2011-04-14 09:47:09 -06:00
|
|
|
extern void usb_create_sysfs_intf_files(struct usb_interface *intf);
|
2008-01-30 16:21:33 -07:00
|
|
|
extern void usb_remove_sysfs_intf_files(struct usb_interface *intf);
|
2008-12-05 12:10:34 -07:00
|
|
|
extern int usb_create_ep_devs(struct device *parent,
|
2008-01-30 16:21:33 -07:00
|
|
|
struct usb_host_endpoint *endpoint,
|
2006-06-14 13:14:34 -06:00
|
|
|
struct usb_device *udev);
|
2008-12-05 12:10:34 -07:00
|
|
|
extern void usb_remove_ep_devs(struct usb_host_endpoint *endpoint);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-30 15:05:22 -06:00
|
|
|
extern void usb_enable_endpoint(struct usb_device *dev,
|
2008-12-31 09:31:33 -07:00
|
|
|
struct usb_host_endpoint *ep, bool reset_toggle);
|
|
|
|
extern void usb_enable_interface(struct usb_device *dev,
|
|
|
|
struct usb_interface *intf, bool reset_toggles);
|
2009-01-15 15:03:33 -07:00
|
|
|
extern void usb_disable_endpoint(struct usb_device *dev, unsigned int epaddr,
|
|
|
|
bool reset_hardware);
|
2008-01-30 16:21:33 -07:00
|
|
|
extern void usb_disable_interface(struct usb_device *dev,
|
2009-01-15 15:03:33 -07:00
|
|
|
struct usb_interface *intf, bool reset_hardware);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern void usb_release_interface_cache(struct kref *ref);
|
2008-01-30 16:21:33 -07:00
|
|
|
extern void usb_disable_device(struct usb_device *dev, int skip_ep0);
|
|
|
|
extern int usb_deauthorize_device(struct usb_device *);
|
|
|
|
extern int usb_authorize_device(struct usb_device *);
|
2007-01-26 06:26:21 -07:00
|
|
|
extern void usb_detect_quirks(struct usb_device *udev);
|
2012-07-19 04:39:13 -06:00
|
|
|
extern void usb_detect_interface_quirks(struct usb_device *udev);
|
2009-10-27 13:20:13 -06:00
|
|
|
extern int usb_remove_device(struct usb_device *udev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
extern int usb_get_device_descriptor(struct usb_device *dev,
|
|
|
|
unsigned int size);
|
2011-09-23 15:19:47 -06:00
|
|
|
extern int usb_get_bos_descriptor(struct usb_device *dev);
|
|
|
|
extern void usb_release_bos_descriptor(struct usb_device *dev);
|
2005-10-24 14:24:14 -06:00
|
|
|
extern char *usb_cache_string(struct usb_device *udev, int index);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern int usb_set_configuration(struct usb_device *dev, int configuration);
|
2007-08-02 22:44:27 -06:00
|
|
|
extern int usb_choose_configuration(struct usb_device *udev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-12-18 07:25:46 -07:00
|
|
|
static inline unsigned usb_get_max_power(struct usb_device *udev,
|
|
|
|
struct usb_host_config *c)
|
|
|
|
{
|
|
|
|
/* SuperSpeed power is in 8 mA units; others are in 2 mA units */
|
|
|
|
unsigned mul = (udev->speed == USB_SPEED_SUPER ? 8 : 2);
|
|
|
|
|
|
|
|
return c->desc.bMaxPower * mul;
|
|
|
|
}
|
|
|
|
|
2014-09-19 09:32:22 -06:00
|
|
|
extern void usb_kick_hub_wq(struct usb_device *dev);
|
2012-07-19 04:39:13 -06:00
|
|
|
extern int usb_match_one_id_intf(struct usb_device *dev,
|
|
|
|
struct usb_host_interface *intf,
|
|
|
|
const struct usb_device_id *id);
|
2007-01-26 06:26:21 -07:00
|
|
|
extern int usb_match_device(struct usb_device *dev,
|
|
|
|
const struct usb_device_id *id);
|
2008-06-23 14:00:40 -06:00
|
|
|
extern void usb_forced_unbind_intf(struct usb_interface *intf);
|
2014-03-12 09:30:38 -06:00
|
|
|
extern void usb_unbind_and_rebind_marked_interfaces(struct usb_device *udev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-07-06 00:13:52 -06:00
|
|
|
extern void usb_hub_release_all_ports(struct usb_device *hdev,
|
2014-03-10 02:36:40 -06:00
|
|
|
struct usb_dev_state *owner);
|
2009-06-29 08:56:54 -06:00
|
|
|
extern bool usb_device_is_owned(struct usb_device *udev);
|
|
|
|
|
2005-04-18 18:39:24 -06:00
|
|
|
extern int usb_hub_init(void);
|
|
|
|
extern void usb_hub_cleanup(void);
|
|
|
|
extern int usb_major_init(void);
|
|
|
|
extern void usb_major_cleanup(void);
|
|
|
|
|
2006-07-01 20:14:24 -06:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
|
2008-08-12 12:34:10 -06:00
|
|
|
extern int usb_suspend(struct device *dev, pm_message_t msg);
|
2008-11-25 14:39:18 -07:00
|
|
|
extern int usb_resume(struct device *dev, pm_message_t msg);
|
2012-01-11 00:38:35 -07:00
|
|
|
extern int usb_resume_complete(struct device *dev);
|
2008-08-12 12:34:10 -06:00
|
|
|
|
2008-11-25 14:39:18 -07:00
|
|
|
extern int usb_port_suspend(struct usb_device *dev, pm_message_t msg);
|
|
|
|
extern int usb_port_resume(struct usb_device *dev, pm_message_t msg);
|
2006-09-26 12:50:20 -06:00
|
|
|
|
2014-11-29 15:47:05 -07:00
|
|
|
extern void usb_autosuspend_device(struct usb_device *udev);
|
|
|
|
extern int usb_autoresume_device(struct usb_device *udev);
|
|
|
|
extern int usb_remote_wakeup(struct usb_device *dev);
|
|
|
|
extern int usb_runtime_suspend(struct device *dev);
|
|
|
|
extern int usb_runtime_resume(struct device *dev);
|
|
|
|
extern int usb_runtime_idle(struct device *dev);
|
|
|
|
extern int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable);
|
|
|
|
|
2006-07-01 20:14:24 -06:00
|
|
|
#else
|
|
|
|
|
2008-11-25 14:39:18 -07:00
|
|
|
static inline int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
|
2007-05-30 14:51:28 -06:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-25 14:39:18 -07:00
|
|
|
static inline int usb_port_resume(struct usb_device *udev, pm_message_t msg)
|
2007-05-30 14:51:28 -06:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-02-20 13:03:32 -07:00
|
|
|
#define usb_autosuspend_device(udev) do {} while (0)
|
2006-11-20 09:38:46 -07:00
|
|
|
static inline int usb_autoresume_device(struct usb_device *udev)
|
2006-09-26 12:50:20 -06:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2006-08-30 13:47:02 -06:00
|
|
|
|
2011-09-23 15:19:52 -06:00
|
|
|
static inline int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2014-11-29 15:47:05 -07:00
|
|
|
|
2006-08-30 13:47:02 -06:00
|
|
|
#endif
|
|
|
|
|
2006-07-01 20:08:06 -06:00
|
|
|
extern struct bus_type usb_bus_type;
|
2014-05-20 19:08:28 -06:00
|
|
|
extern struct mutex usb_port_peer_mutex;
|
2007-03-13 08:59:31 -06:00
|
|
|
extern struct device_type usb_device_type;
|
|
|
|
extern struct device_type usb_if_device_type;
|
2009-05-04 11:48:32 -06:00
|
|
|
extern struct device_type usb_ep_device_type;
|
2012-09-04 23:44:33 -06:00
|
|
|
extern struct device_type usb_port_device_type;
|
2006-07-01 20:08:49 -06:00
|
|
|
extern struct usb_device_driver usb_generic_driver;
|
|
|
|
|
2006-08-26 20:48:11 -06:00
|
|
|
static inline int is_usb_device(const struct device *dev)
|
2006-07-01 20:08:49 -06:00
|
|
|
{
|
2007-03-13 08:59:31 -06:00
|
|
|
return dev->type == &usb_device_type;
|
2006-07-01 20:08:49 -06:00
|
|
|
}
|
|
|
|
|
2009-05-04 11:48:32 -06:00
|
|
|
static inline int is_usb_interface(const struct device *dev)
|
|
|
|
{
|
|
|
|
return dev->type == &usb_if_device_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int is_usb_endpoint(const struct device *dev)
|
|
|
|
{
|
|
|
|
return dev->type == &usb_ep_device_type;
|
|
|
|
}
|
|
|
|
|
2012-09-04 23:44:33 -06:00
|
|
|
static inline int is_usb_port(const struct device *dev)
|
|
|
|
{
|
|
|
|
return dev->type == &usb_port_device_type;
|
|
|
|
}
|
|
|
|
|
2006-07-01 20:08:49 -06:00
|
|
|
/* Do the same for device drivers and interface drivers. */
|
|
|
|
|
|
|
|
static inline int is_usb_device_driver(struct device_driver *drv)
|
|
|
|
{
|
|
|
|
return container_of(drv, struct usbdrv_wrap, driver)->
|
|
|
|
for_devices;
|
|
|
|
}
|
2005-09-22 23:45:26 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* for labeling diagnostics */
|
|
|
|
extern const char *usbcore_name;
|
|
|
|
|
2008-04-30 13:37:19 -06:00
|
|
|
/* sysfs stuff */
|
2009-06-24 11:06:31 -06:00
|
|
|
extern const struct attribute_group *usb_device_groups[];
|
|
|
|
extern const struct attribute_group *usb_interface_groups[];
|
2008-04-30 13:37:19 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* usbfs stuff */
|
usbfs: private mutex for open, release, and remove
The usbfs code doesn't provide sufficient mutual exclusion among open,
release, and remove. Release vs. remove is okay because they both
acquire the device lock, but open is not exclusive with either one. All
three routines modify the udev->filelist linked list, so they must not
run concurrently.
Apparently someone gave this a minimum amount of thought in the past by
explicitly acquiring the BKL at the start of the usbdev_open routine.
Oddly enough, there's a comment pointing out that locking is unnecessary
because chrdev_open already has acquired the BKL.
But this ignores the point that the files in /proc/bus/usb/* are not
char device files; they are regular files and so they don't get any
special locking. Furthermore it's necessary to acquire the same lock in
the release and remove routines, which the code does not do.
Yet another problem arises because the same file_operations structure is
accessible through both the /proc/bus/usb/* and /dev/usb/usbdev* file
nodes. Even when one of them has been removed, it's still possible for
userspace to open the other. So simple locking around the individual
remove routines is insufficient; we need to lock the entire
usb_notify_remove_device notifier chain.
Rather than rely on the BKL, this patch (as723) introduces a new private
mutex for the purpose. Holding the BKL while invoking a notifier chain
doesn't seem like a good idea.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-07-01 20:05:01 -06:00
|
|
|
extern struct mutex usbfs_mutex;
|
2005-04-16 16:20:36 -06:00
|
|
|
extern struct usb_driver usbfs_driver;
|
2006-08-05 17:37:11 -06:00
|
|
|
extern const struct file_operations usbfs_devices_fops;
|
2007-03-13 08:59:31 -06:00
|
|
|
extern const struct file_operations usbdev_file_operations;
|
2005-04-16 16:20:36 -06:00
|
|
|
extern void usbfs_conn_disc_event(void);
|
|
|
|
|
2007-03-13 08:59:31 -06:00
|
|
|
extern int usb_devio_init(void);
|
|
|
|
extern void usb_devio_cleanup(void);
|
2005-04-18 18:39:24 -06:00
|
|
|
|
2014-05-20 19:08:40 -06:00
|
|
|
/*
|
|
|
|
* Firmware specific cookie identifying a port's location. '0' == no location
|
|
|
|
* data available
|
|
|
|
*/
|
|
|
|
typedef u32 usb_port_location_t;
|
|
|
|
|
2005-06-20 22:15:16 -06:00
|
|
|
/* internal notify stuff */
|
|
|
|
extern void usb_notify_add_device(struct usb_device *udev);
|
|
|
|
extern void usb_notify_remove_device(struct usb_device *udev);
|
|
|
|
extern void usb_notify_add_bus(struct usb_bus *ubus);
|
|
|
|
extern void usb_notify_remove_bus(struct usb_bus *ubus);
|
2013-01-21 07:18:00 -07:00
|
|
|
extern void usb_hub_adjust_deviceremovable(struct usb_device *hdev,
|
|
|
|
struct usb_hub_descriptor *desc);
|
2005-06-20 22:15:16 -06:00
|
|
|
|
2012-05-11 02:08:27 -06:00
|
|
|
#ifdef CONFIG_ACPI
|
|
|
|
extern int usb_acpi_register(void);
|
|
|
|
extern void usb_acpi_unregister(void);
|
2012-09-04 23:44:33 -06:00
|
|
|
extern acpi_handle usb_get_hub_port_acpi_handle(struct usb_device *hdev,
|
|
|
|
int port1);
|
2012-05-11 02:08:27 -06:00
|
|
|
#else
|
|
|
|
static inline int usb_acpi_register(void) { return 0; };
|
|
|
|
static inline void usb_acpi_unregister(void) { };
|
|
|
|
#endif
|