USB: add power/persist device attribute

This patch (as920) adds an extra level of protection to the
USB-Persist facility.  Now it will apply by default only to hubs; for
all other devices the user must enable it explicitly by setting the
power/persist device attribute.

The disconnect_all_children() routine in hub.c has been removed and
its code placed inline.  This is the way it was originally as part of
hub_pre_reset(); the revised usage in hub_reset_resume() is
sufficiently different that the code can no longer be shared.
Likewise, mark_children_for_reset() is now inline as part of
hub_reset_resume().  The end result looks much cleaner than before.

The sysfs interface is updated to add the new attribute file, and
there are corresponding documentation updates.

Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

3 files changed, 110 insertions, 56 deletions

diff --git a/drivers/usb/core/Kconfig b/drivers/usb/core/Kconfig
index 5113ef4cb7f6..97b09f282705 100644
--- a/drivers/usb/core/Kconfig
+++ b/drivers/usb/core/Kconfig
@@ -91,12 +91,15 @@ config USB_PERSIST
         depends on USB && PM && EXPERIMENTAL
         default n
         help
-          If you say Y here, USB device data structures will remain
+
+          If you say Y here and enable the "power/persist" attribute
+          for a USB device, the device's data structures will remain
           persistent across system suspend, even if the USB bus loses
-          power.  (This includes software-suspend, also known as swsusp,
-          or suspend-to-disk.)  The devices will reappear as if by magic
-          when the system wakes up, with no need to unmount USB filesystems,
-          rmmod host-controller drivers, or do anything else.
+          power.  (This includes hibernation, also known as swsusp or
+          suspend-to-disk.)  The devices will reappear as if by magic
+          when the system wakes up, with no need to unmount USB
+          filesystems, rmmod host-controller drivers, or do anything
+          else.
 
                 WARNING: This option can be dangerous!
 
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index c4cdb69a6e9e..50e79010401c 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -596,27 +596,18 @@ static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
         kick_khubd(hub);
 }
 
-static void disconnect_all_children(struct usb_hub *hub, int logical)
-{
-        struct usb_device *hdev = hub->hdev;
-        int port1;
-
-        for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
-                if (hdev->children[port1-1]) {
-                        if (logical)
-                                hub_port_logical_disconnect(hub, port1);
-                        else
-                                usb_disconnect(&hdev->children[port1-1]);
-                }
-        }
-}
-
 /* caller has locked the hub device */
 static int hub_pre_reset(struct usb_interface *intf)
 {
         struct usb_hub *hub = usb_get_intfdata(intf);
+        struct usb_device *hdev = hub->hdev;
+        int i;
 
-        disconnect_all_children(hub, 0);
+        /* Disconnect all the children */
+        for (i = 0; i < hdev->maxchild; ++i) {
+                if (hdev->children[i])
+                        usb_disconnect(&hdev->children[i]);
+        }
         hub_quiesce(hub);
         return 0;
 }
@@ -1872,50 +1863,39 @@ static int hub_resume(struct usb_interface *intf)
         return 0;
 }
 
-#ifdef  CONFIG_USB_PERSIST
-
-/* For "persistent-device" resets we must mark the child devices for reset
- * and turn off a possible connect-change status (so khubd won't disconnect
- * them later).
- */
-static void mark_children_for_reset_resume(struct usb_hub *hub)
+static int hub_reset_resume(struct usb_interface *intf)
 {
+        struct usb_hub *hub = usb_get_intfdata(intf);
         struct usb_device *hdev = hub->hdev;
         int port1;
 
+        hub_power_on(hub);
+
         for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
                 struct usb_device *child = hdev->children[port1-1];
 
                 if (child) {
-                        child->reset_resume = 1;
-                        clear_port_feature(hdev, port1,
-                                        USB_PORT_FEAT_C_CONNECTION);
+
+                        /* For "USB_PERSIST"-enabled children we must
+                         * mark the child device for reset-resume and
+                         * turn off the connect-change status to prevent
+                         * khubd from disconnecting it later.
+                         */
+                        if (USB_PERSIST && child->persist_enabled) {
+                                child->reset_resume = 1;
+                                clear_port_feature(hdev, port1,
+                                                USB_PORT_FEAT_C_CONNECTION);
+
+                        /* Otherwise we must disconnect the child,
+                         * but as we may not lock the child device here
+                         * we have to do a "logical" disconnect.
+                         */
+                        } else {
+                                hub_port_logical_disconnect(hub, port1);
+                        }
                 }
         }
-}
-
-#else
-
-static inline void mark_children_for_reset_resume(struct usb_hub *hub)
-{ }
-
-#endif  /* CONFIG_USB_PERSIST */
-
-static int hub_reset_resume(struct usb_interface *intf)
-{
-        struct usb_hub *hub = usb_get_intfdata(intf);
 
-        hub_power_on(hub);
-        if (USB_PERSIST)
-                mark_children_for_reset_resume(hub);
-        else {
-                /* Reset-resume doesn't call pre_reset, so we have to
-                 * disconnect the children here.  But we may not lock
-                 * the child devices, so we have to do a "logical"
-                 * disconnect.
-                 */
-                disconnect_all_children(hub, 1);
-        }
         hub_activate(hub);
         return 0;
 }
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index be37c863fdfb..5dfe31bc32ba 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -169,6 +169,73 @@ show_quirks(struct device *dev, struct device_attribute *attr, char *buf)
 }
 static DEVICE_ATTR(quirks, S_IRUGO, show_quirks, NULL);
 
+
+#if defined(CONFIG_USB_PERSIST) || defined(CONFIG_USB_SUSPEND)
+static const char power_group[] = "power";
+#endif
+
+#ifdef  CONFIG_USB_PERSIST
+
+static ssize_t
+show_persist(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct usb_device *udev = to_usb_device(dev);
+
+        return sprintf(buf, "%d\n", udev->persist_enabled);
+}
+
+static ssize_t
+set_persist(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        struct usb_device *udev = to_usb_device(dev);
+        int value;
+
+        /* Hubs are always enabled for USB_PERSIST */
+        if (udev->descriptor.bDeviceClass == USB_CLASS_HUB)
+                return -EPERM;
+
+        if (sscanf(buf, "%d", &value) != 1)
+                return -EINVAL;
+        usb_pm_lock(udev);
+        udev->persist_enabled = !!value;
+        usb_pm_unlock(udev);
+        return count;
+}
+
+static DEVICE_ATTR(persist, S_IRUGO | S_IWUSR, show_persist, set_persist);
+
+static int add_persist_attributes(struct device *dev)
+{
+        int rc = 0;
+
+        if (is_usb_device(dev)) {
+                struct usb_device *udev = to_usb_device(dev);
+
+                /* Hubs are automatically enabled for USB_PERSIST */
+                if (udev->descriptor.bDeviceClass == USB_CLASS_HUB)
+                        udev->persist_enabled = 1;
+                rc = sysfs_add_file_to_group(&dev->kobj,
+                                &dev_attr_persist.attr,
+                                power_group);
+        }
+        return rc;
+}
+
+static void remove_persist_attributes(struct device *dev)
+{
+        sysfs_remove_file_from_group(&dev->kobj,
+                        &dev_attr_persist.attr,
+                        power_group);
+}
+
+#else
+
+#define add_persist_attributes(dev)     0
+#define remove_persist_attributes(dev)  do {} while (0)
+
+#endif  /* CONFIG_USB_PERSIST */
+
 #ifdef  CONFIG_USB_SUSPEND
 
 static ssize_t
@@ -276,8 +343,6 @@ set_level(struct device *dev, struct device_attribute *attr,
 
 static DEVICE_ATTR(level, S_IRUGO | S_IWUSR, show_level, set_level);
 
-static char power_group[] = "power";
-
 static int add_power_attributes(struct device *dev)
 {
         int rc = 0;
@@ -311,6 +376,7 @@ static void remove_power_attributes(struct device *dev)
 
 #endif  /* CONFIG_USB_SUSPEND */
 
+
 /* Descriptor fields */
 #define usb_descriptor_attr_le16(field, format_string)                  \
 static ssize_t                                                          \
@@ -384,6 +450,10 @@ int usb_create_sysfs_dev_files(struct usb_device *udev)
         if (retval)
                 return retval;
 
+        retval = add_persist_attributes(dev);
+        if (retval)
+                goto error;
+
         retval = add_power_attributes(dev);
         if (retval)
                 goto error;
@@ -421,6 +491,7 @@ void usb_remove_sysfs_dev_files(struct usb_device *udev)
         device_remove_file(dev, &dev_attr_product);
         device_remove_file(dev, &dev_attr_serial);
         remove_power_attributes(dev);
+        remove_persist_attributes(dev);
         sysfs_remove_group(&dev->kobj, &dev_attr_grp);
 }