USB: Export suspend statistics

This patch exports two statistics to userspace:
/sys/bus/usb/device/.../power/connected_duration
/sys/bus/usb/device/.../power/active_duration

connected_duration is the total time (in msec) that the device has
been connected.  active_duration is the total time the device has not
been suspended.  With these two statistics, tools like PowerTOP can
calculate the percentage time that a device is active, i.e. not
suspended or auto-suspended.

Users can also use the active_duration to check if a device is actually
autosuspended.  Currently, they can set power/level to auto and
power/autosuspend to a positive timeout, but there's no way to know from
userspace if a device was actually autosuspended without looking at the
dmesg output.  These statistics will be useful in creating an automated
userspace script to test autosuspend for USB devices.

Signed-off-by: Sarah Sharp <sarah.a.sharp@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index cc93aa9336fe1d25e6b063d4c3ec627c8437223b..53fe049b40f57661fb14ba84bc1ba825ba36a002 100644 (file)
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -1034,8 +1034,10 @@ static void recursively_mark_NOTATTACHED(struct usb_device *udev)
                if (udev->children[i])
                        recursively_mark_NOTATTACHED(udev->children[i]);
        }
-       if (udev->state == USB_STATE_SUSPENDED)
+       if (udev->state == USB_STATE_SUSPENDED) {
                udev->discon_suspended = 1;
+               udev->active_duration -= jiffies;
+       }
        udev->state = USB_STATE_NOTATTACHED;
 }
 
@@ -1084,6 +1086,12 @@ void usb_set_device_state(struct usb_device *udev,
                        else
                                device_init_wakeup(&udev->dev, 0);
                }
+               if (udev->state == USB_STATE_SUSPENDED &&
+                       new_state != USB_STATE_SUSPENDED)
+                       udev->active_duration -= jiffies;
+               else if (new_state == USB_STATE_SUSPENDED &&
+                               udev->state != USB_STATE_SUSPENDED)
+                       udev->active_duration += jiffies;
                udev->state = new_state;
        } else
                recursively_mark_NOTATTACHED(udev);

diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 32bd130b1eed33fc542fc39bc5f10c1de4695916..021b1d37462c89a6f145c0539a7246307ddbb459 100644 (file)
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -248,6 +248,41 @@ static void remove_persist_attributes(struct device *dev)
 
 #ifdef CONFIG_USB_SUSPEND
 
+static ssize_t
+show_connected_duration(struct device *dev, struct device_attribute *attr,
+               char *buf)
+{
+       struct usb_device *udev = to_usb_device(dev);
+
+       return sprintf(buf, "%u\n",
+                       jiffies_to_msecs(jiffies - udev->connect_time));
+}
+
+static DEVICE_ATTR(connected_duration, S_IRUGO, show_connected_duration, NULL);
+
+/*
+ * If the device is resumed, the last time the device was suspended has
+ * been pre-subtracted from active_duration.  We add the current time to
+ * get the duration that the device was actually active.
+ *
+ * If the device is suspended, the active_duration is up-to-date.
+ */
+static ssize_t
+show_active_duration(struct device *dev, struct device_attribute *attr,
+               char *buf)
+{
+       struct usb_device *udev = to_usb_device(dev);
+       int duration;
+
+       if (udev->state != USB_STATE_SUSPENDED)
+               duration = jiffies_to_msecs(jiffies + udev->active_duration);
+       else
+               duration = jiffies_to_msecs(udev->active_duration);
+       return sprintf(buf, "%u\n", duration);
+}
+
+static DEVICE_ATTR(active_duration, S_IRUGO, show_active_duration, NULL);
+
 static ssize_t
 show_autosuspend(struct device *dev, struct device_attribute *attr, char *buf)
 {
@@ -365,12 +400,26 @@ static int add_power_attributes(struct device *dev)
                        rc = sysfs_add_file_to_group(&dev->kobj,
                                        &dev_attr_level.attr,
                                        power_group);
+               if (rc == 0)
+                       rc = sysfs_add_file_to_group(&dev->kobj,
+                                       &dev_attr_connected_duration.attr,
+                                       power_group);
+               if (rc == 0)
+                       rc = sysfs_add_file_to_group(&dev->kobj,
+                                       &dev_attr_active_duration.attr,
+                                       power_group);
        }
        return rc;
 }
 
 static void remove_power_attributes(struct device *dev)
 {
+       sysfs_remove_file_from_group(&dev->kobj,
+                       &dev_attr_active_duration.attr,
+                       power_group);
+       sysfs_remove_file_from_group(&dev->kobj,
+                       &dev_attr_connected_duration.attr,
+                       power_group);
        sysfs_remove_file_from_group(&dev->kobj,
                        &dev_attr_level.attr,
                        power_group);

diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index bc5edacb0c342276fa8e5e2fb942ee36430133dc..fdb444d8127148e2d5babded4af869b053cb83e0 100644 (file)
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -339,6 +339,8 @@ usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1)
        mutex_init(&dev->pm_mutex);
        INIT_DELAYED_WORK(&dev->autosuspend, usb_autosuspend_work);
        dev->autosuspend_delay = usb_autosuspend_delay * HZ;
+       dev->connect_time = jiffies;
+       dev->active_duration = -jiffies;
 #endif
        if (root_hub)   /* Root hub always ok [and always wired] */
                dev->authorized = 1;

diff --git a/include/linux/usb.h b/include/linux/usb.h
index 8aae045e9a2e3e90a2deecd3191072dfb809ed43..f8a60756fe2aad2d44be283c4427e8856442f4bf 100644 (file)
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -419,12 +419,15 @@ struct usb_device {
        u32 quirks;                     /* quirks of the whole device */
        atomic_t urbnum;                /* number of URBs submitted for the whole device */
 
+       unsigned long active_duration;  /* total time device is not suspended */
+
 #ifdef CONFIG_PM
        struct delayed_work autosuspend; /* for delayed autosuspends */
        struct mutex pm_mutex;          /* protects PM operations */
 
        unsigned long last_busy;        /* time of last use */
        int autosuspend_delay;          /* in jiffies */
+       unsigned long connect_time;     /* time device was first connected */
 
        unsigned auto_pm:1;             /* autosuspend/resume in progress */
        unsigned do_remote_wakeup:1;    /* remote wakeup should be enabled */