driver core: bus_add_driver should return an error if no bus
[linux-2.6.git] / drivers / base / bus.c
index e3f915a..1d76e23 100644 (file)
@@ -8,7 +8,6 @@
  *
  */
 
-#include <linux/config.h>
 #include <linux/device.h>
 #include <linux/module.h>
 #include <linux/errno.h>
@@ -28,6 +27,9 @@
 #define to_driver(obj) container_of(obj, struct device_driver, kobj)
 
 
+static int __must_check bus_rescan_devices_helper(struct device *dev,
+                                               void *data);
+
 static ssize_t
 drv_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
 {
@@ -61,8 +63,19 @@ static struct sysfs_ops driver_sysfs_ops = {
 
 static void driver_release(struct kobject * kobj)
 {
-       struct device_driver * drv = to_driver(kobj);
-       complete(&drv->unloaded);
+       /*
+        * Yes this is an empty release function, it is this way because struct
+        * device is always a static object, not a dynamic one.  Yes, this is
+        * not nice and bad, but remember, drivers are code, reference counted
+        * by the module count, not a device, which is really data.  And yes,
+        * in the future I do want to have all drivers be created dynamically,
+        * and am working toward that goal, but it will take a bit longer...
+        *
+        * But do not let this example give _anyone_ the idea that they can
+        * create a release function without any code in it at all, to do that
+        * is almost always wrong.  If you have any questions about this,
+        * please send an email to <greg@kroah.com>
+        */
 }
 
 static struct kobj_type ktype_driver = {
@@ -130,9 +143,10 @@ static struct kobj_type ktype_bus = {
 
 };
 
-decl_subsys(bus, &ktype_bus, NULL);
+static decl_subsys(bus, &ktype_bus, NULL);
 
 
+#ifdef CONFIG_HOTPLUG
 /* Manually detach a device from its associated driver. */
 static int driver_helper(struct device *dev, void *data)
 {
@@ -186,6 +200,11 @@ static ssize_t driver_bind(struct device_driver *drv,
                up(&dev->sem);
                if (dev->parent)
                        up(&dev->parent->sem);
+
+               if (err > 0)            /* success */
+                       err = count;
+               else if (err == 0)      /* driver didn't accept device */
+                       err = -ENODEV;
        }
        put_device(dev);
        put_bus(bus);
@@ -193,6 +212,34 @@ static ssize_t driver_bind(struct device_driver *drv,
 }
 static DRIVER_ATTR(bind, S_IWUSR, NULL, driver_bind);
 
+static ssize_t show_drivers_autoprobe(struct bus_type *bus, char *buf)
+{
+       return sprintf(buf, "%d\n", bus->drivers_autoprobe);
+}
+
+static ssize_t store_drivers_autoprobe(struct bus_type *bus,
+                                      const char *buf, size_t count)
+{
+       if (buf[0] == '0')
+               bus->drivers_autoprobe = 0;
+       else
+               bus->drivers_autoprobe = 1;
+       return count;
+}
+
+static ssize_t store_drivers_probe(struct bus_type *bus,
+                                  const char *buf, size_t count)
+{
+       struct device *dev;
+
+       dev = bus_find_device(bus, NULL, (void *)buf, driver_helper);
+       if (!dev)
+               return -ENODEV;
+       if (bus_rescan_devices_helper(dev, NULL) != 0)
+               return -EINVAL;
+       return count;
+}
+#endif
 
 static struct device * next_device(struct klist_iter * i)
 {
@@ -317,27 +364,25 @@ int bus_for_each_drv(struct bus_type * bus, struct device_driver * start,
        return error;
 }
 
-static int device_add_attrs(struct bus_type * bus, struct device * dev)
+static int device_add_attrs(struct bus_type *bus, struct device *dev)
 {
        int error = 0;
        int i;
 
-       if (bus->dev_attrs) {
-               for (i = 0; attr_name(bus->dev_attrs[i]); i++) {
-                       error = device_create_file(dev,&bus->dev_attrs[i]);
-                       if (error)
-                               goto Err;
+       if (!bus->dev_attrs)
+               return 0;
+
+       for (i = 0; attr_name(bus->dev_attrs[i]); i++) {
+               error = device_create_file(dev,&bus->dev_attrs[i]);
+               if (error) {
+                       while (--i >= 0)
+                               device_remove_file(dev, &bus->dev_attrs[i]);
+                       break;
                }
        }
- Done:
        return error;
- Err:
-       while (--i >= 0)
-               device_remove_file(dev,&bus->dev_attrs[i]);
-       goto Done;
 }
 
-
 static void device_remove_attrs(struct bus_type * bus, struct device * dev)
 {
        int i;
@@ -348,14 +393,28 @@ static void device_remove_attrs(struct bus_type * bus, struct device * dev)
        }
 }
 
+#ifdef CONFIG_SYSFS_DEPRECATED
+static int make_deprecated_bus_links(struct device *dev)
+{
+       return sysfs_create_link(&dev->kobj,
+                                &dev->bus->subsys.kset.kobj, "bus");
+}
+
+static void remove_deprecated_bus_links(struct device *dev)
+{
+       sysfs_remove_link(&dev->kobj, "bus");
+}
+#else
+static inline int make_deprecated_bus_links(struct device *dev) { return 0; }
+static inline void remove_deprecated_bus_links(struct device *dev) { }
+#endif
 
 /**
  *     bus_add_device - add device to bus
  *     @dev:   device being added
  *
  *     - Add the device to its bus's list of devices.
- *     - Try to attach to driver.
- *     - Create link to device's physical location.
+ *     - Create link to device's bus.
  */
 int bus_add_device(struct device * dev)
 {
@@ -364,18 +423,59 @@ int bus_add_device(struct device * dev)
 
        if (bus) {
                pr_debug("bus %s: add device %s\n", bus->name, dev->bus_id);
-               device_attach(dev);
-               klist_add_tail(&dev->knode_bus, &bus->klist_devices);
                error = device_add_attrs(bus, dev);
-               if (!error) {
-                       sysfs_create_link(&bus->devices.kobj, &dev->kobj, dev->bus_id);
-                       sysfs_create_link(&dev->kobj, &dev->bus->subsys.kset.kobj, "bus");
-               }
+               if (error)
+                       goto out_put;
+               error = sysfs_create_link(&bus->devices.kobj,
+                                               &dev->kobj, dev->bus_id);
+               if (error)
+                       goto out_id;
+               error = sysfs_create_link(&dev->kobj,
+                               &dev->bus->subsys.kset.kobj, "subsystem");
+               if (error)
+                       goto out_subsys;
+               error = make_deprecated_bus_links(dev);
+               if (error)
+                       goto out_deprecated;
        }
+       return 0;
+
+out_deprecated:
+       sysfs_remove_link(&dev->kobj, "subsystem");
+out_subsys:
+       sysfs_remove_link(&bus->devices.kobj, dev->bus_id);
+out_id:
+       device_remove_attrs(bus, dev);
+out_put:
+       put_bus(dev->bus);
        return error;
 }
 
 /**
+ *     bus_attach_device - add device to bus
+ *     @dev:   device tried to attach to a driver
+ *
+ *     - Add device to bus's list of devices.
+ *     - Try to attach to driver.
+ */
+void bus_attach_device(struct device * dev)
+{
+       struct bus_type *bus = dev->bus;
+       int ret = 0;
+
+       if (bus) {
+               dev->is_registered = 1;
+               if (bus->drivers_autoprobe)
+                       ret = device_attach(dev);
+               WARN_ON(ret < 0);
+               if (ret >= 0)
+                       klist_add_tail(&dev->knode_bus, &bus->klist_devices);
+               else
+                       dev->is_registered = 0;
+       }
+}
+
+/**
  *     bus_remove_device - remove device from bus
  *     @dev:   device to be removed
  *
@@ -387,10 +487,14 @@ int bus_add_device(struct device * dev)
 void bus_remove_device(struct device * dev)
 {
        if (dev->bus) {
-               sysfs_remove_link(&dev->kobj, "bus");
+               sysfs_remove_link(&dev->kobj, "subsystem");
+               remove_deprecated_bus_links(dev);
                sysfs_remove_link(&dev->bus->devices.kobj, dev->bus_id);
                device_remove_attrs(dev->bus, dev);
-               klist_remove(&dev->knode_bus);
+               if (dev->is_registered) {
+                       dev->is_registered = 0;
+                       klist_del(&dev->knode_bus);
+               }
                pr_debug("bus %s: remove device %s\n", dev->bus->name, dev->bus_id);
                device_release_driver(dev);
                put_bus(dev->bus);
@@ -428,42 +532,116 @@ static void driver_remove_attrs(struct bus_type * bus, struct device_driver * dr
        }
 }
 
+#ifdef CONFIG_HOTPLUG
+/*
+ * Thanks to drivers making their tables __devinit, we can't allow manual
+ * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled.
+ */
+static int __must_check add_bind_files(struct device_driver *drv)
+{
+       int ret;
+
+       ret = driver_create_file(drv, &driver_attr_unbind);
+       if (ret == 0) {
+               ret = driver_create_file(drv, &driver_attr_bind);
+               if (ret)
+                       driver_remove_file(drv, &driver_attr_unbind);
+       }
+       return ret;
+}
+
+static void remove_bind_files(struct device_driver *drv)
+{
+       driver_remove_file(drv, &driver_attr_bind);
+       driver_remove_file(drv, &driver_attr_unbind);
+}
+
+static int add_probe_files(struct bus_type *bus)
+{
+       int retval;
+
+       bus->drivers_probe_attr.attr.name = "drivers_probe";
+       bus->drivers_probe_attr.attr.mode = S_IWUSR;
+       bus->drivers_probe_attr.attr.owner = bus->owner;
+       bus->drivers_probe_attr.store = store_drivers_probe;
+       retval = bus_create_file(bus, &bus->drivers_probe_attr);
+       if (retval)
+               goto out;
+
+       bus->drivers_autoprobe_attr.attr.name = "drivers_autoprobe";
+       bus->drivers_autoprobe_attr.attr.mode = S_IWUSR | S_IRUGO;
+       bus->drivers_autoprobe_attr.attr.owner = bus->owner;
+       bus->drivers_autoprobe_attr.show = show_drivers_autoprobe;
+       bus->drivers_autoprobe_attr.store = store_drivers_autoprobe;
+       retval = bus_create_file(bus, &bus->drivers_autoprobe_attr);
+       if (retval)
+               bus_remove_file(bus, &bus->drivers_probe_attr);
+out:
+       return retval;
+}
+
+static void remove_probe_files(struct bus_type *bus)
+{
+       bus_remove_file(bus, &bus->drivers_autoprobe_attr);
+       bus_remove_file(bus, &bus->drivers_probe_attr);
+}
+#else
+static inline int add_bind_files(struct device_driver *drv) { return 0; }
+static inline void remove_bind_files(struct device_driver *drv) {}
+static inline int add_probe_files(struct bus_type *bus) { return 0; }
+static inline void remove_probe_files(struct bus_type *bus) {}
+#endif
 
 /**
  *     bus_add_driver - Add a driver to the bus.
  *     @drv:   driver.
  *
  */
-int bus_add_driver(struct device_driver * drv)
+int bus_add_driver(struct device_driver *drv)
 {
        struct bus_type * bus = get_bus(drv->bus);
        int error = 0;
 
-       if (bus) {
-               pr_debug("bus %s: add driver %s\n", bus->name, drv->name);
-               error = kobject_set_name(&drv->kobj, "%s", drv->name);
-               if (error) {
-                       put_bus(bus);
-                       return error;
-               }
-               drv->kobj.kset = &bus->drivers;
-               if ((error = kobject_register(&drv->kobj))) {
-                       put_bus(bus);
-                       return error;
-               }
-
-               driver_attach(drv);
-               klist_add_tail(&drv->knode_bus, &bus->klist_drivers);
-               module_add_driver(drv->owner, drv);
+       if (!bus)
+               return -EINVAL;
 
-               driver_add_attrs(bus, drv);
-               driver_create_file(drv, &driver_attr_unbind);
-               driver_create_file(drv, &driver_attr_bind);
+       pr_debug("bus %s: add driver %s\n", bus->name, drv->name);
+       error = kobject_set_name(&drv->kobj, "%s", drv->name);
+       if (error)
+               goto out_put_bus;
+       drv->kobj.kset = &bus->drivers;
+       if ((error = kobject_register(&drv->kobj)))
+               goto out_put_bus;
+
+       if (drv->bus->drivers_autoprobe) {
+               error = driver_attach(drv);
+               if (error)
+                       goto out_unregister;
+       }
+       klist_add_tail(&drv->knode_bus, &bus->klist_drivers);
+       module_add_driver(drv->owner, drv);
+
+       error = driver_add_attrs(bus, drv);
+       if (error) {
+               /* How the hell do we get out of this pickle? Give up */
+               printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",
+                       __FUNCTION__, drv->name);
+       }
+       error = add_bind_files(drv);
+       if (error) {
+               /* Ditto */
+               printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
+                       __FUNCTION__, drv->name);
        }
+
+       return error;
+out_unregister:
+       kobject_unregister(&drv->kobj);
+out_put_bus:
+       put_bus(bus);
        return error;
 }
 
-
 /**
  *     bus_remove_driver - delete driver from bus's knowledge.
  *     @drv:   driver.
@@ -475,31 +653,34 @@ int bus_add_driver(struct device_driver * drv)
 
 void bus_remove_driver(struct device_driver * drv)
 {
-       if (drv->bus) {
-               driver_remove_file(drv, &driver_attr_bind);
-               driver_remove_file(drv, &driver_attr_unbind);
-               driver_remove_attrs(drv->bus, drv);
-               klist_remove(&drv->knode_bus);
-               pr_debug("bus %s: remove driver %s\n", drv->bus->name, drv->name);
-               driver_detach(drv);
-               module_remove_driver(drv);
-               kobject_unregister(&drv->kobj);
-               put_bus(drv->bus);
-       }
+       if (!drv->bus)
+               return;
+
+       remove_bind_files(drv);
+       driver_remove_attrs(drv->bus, drv);
+       klist_remove(&drv->knode_bus);
+       pr_debug("bus %s: remove driver %s\n", drv->bus->name, drv->name);
+       driver_detach(drv);
+       module_remove_driver(drv);
+       kobject_unregister(&drv->kobj);
+       put_bus(drv->bus);
 }
 
 
 /* Helper for bus_rescan_devices's iter */
-static int bus_rescan_devices_helper(struct device *dev, void *data)
+static int __must_check bus_rescan_devices_helper(struct device *dev,
+                                               void *data)
 {
+       int ret = 0;
+
        if (!dev->driver) {
                if (dev->parent)        /* Needed for USB */
                        down(&dev->parent->sem);
-               device_attach(dev);
+               ret = device_attach(dev);
                if (dev->parent)
                        up(&dev->parent->sem);
        }
-       return 0;
+       return ret < 0 ? ret : 0;
 }
 
 /**
@@ -510,15 +691,37 @@ static int bus_rescan_devices_helper(struct device *dev, void *data)
  * attached and rescan it against existing drivers to see if it matches
  * any by calling device_attach() for the unbound devices.
  */
-void bus_rescan_devices(struct bus_type * bus)
+int bus_rescan_devices(struct bus_type * bus)
 {
-       bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper);
+       return bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper);
 }
 
+/**
+ * device_reprobe - remove driver for a device and probe for a new driver
+ * @dev: the device to reprobe
+ *
+ * This function detaches the attached driver (if any) for the given
+ * device and restarts the driver probing process.  It is intended
+ * to use if probing criteria changed during a devices lifetime and
+ * driver attachment should change accordingly.
+ */
+int device_reprobe(struct device *dev)
+{
+       if (dev->driver) {
+               if (dev->parent)        /* Needed for USB */
+                       down(&dev->parent->sem);
+               device_release_driver(dev);
+               if (dev->parent)
+                       up(&dev->parent->sem);
+       }
+       return bus_rescan_devices_helper(dev, NULL);
+}
+EXPORT_SYMBOL_GPL(device_reprobe);
 
-struct bus_type * get_bus(struct bus_type * bus)
+struct bus_type *get_bus(struct bus_type *bus)
 {
-       return bus ? container_of(subsys_get(&bus->subsys), struct bus_type, subsys) : NULL;
+       return bus ? container_of(subsys_get(&bus->subsys),
+                               struct bus_type, subsys) : NULL;
 }
 
 void put_bus(struct bus_type * bus)
@@ -536,12 +739,13 @@ void put_bus(struct bus_type * bus)
  *
  *     Note that kset_find_obj increments bus' reference count.
  */
-
+#if 0
 struct bus_type * find_bus(char * name)
 {
        struct kobject * k = kset_find_obj(&bus_subsys.kset, name);
        return k ? to_bus(k) : NULL;
 }
+#endif  /*  0  */
 
 
 /**
@@ -592,22 +796,6 @@ static void klist_devices_put(struct klist_node *n)
        put_device(dev);
 }
 
-static void klist_drivers_get(struct klist_node *n)
-{
-       struct device_driver *drv = container_of(n, struct device_driver,
-                                                knode_bus);
-
-       get_driver(drv);
-}
-
-static void klist_drivers_put(struct klist_node *n)
-{
-       struct device_driver *drv = container_of(n, struct device_driver,
-                                                knode_bus);
-
-       put_driver(drv);
-}
-
 /**
  *     bus_register - register a bus with the system.
  *     @bus:   bus.
@@ -620,6 +808,8 @@ int bus_register(struct bus_type * bus)
 {
        int retval;
 
+       BLOCKING_INIT_NOTIFIER_HEAD(&bus->bus_notifier);
+
        retval = kobject_set_name(&bus->subsys.kset.kobj, "%s", bus->name);
        if (retval)
                goto out;
@@ -643,12 +833,24 @@ int bus_register(struct bus_type * bus)
                goto bus_drivers_fail;
 
        klist_init(&bus->klist_devices, klist_devices_get, klist_devices_put);
-       klist_init(&bus->klist_drivers, klist_drivers_get, klist_drivers_put);
-       bus_add_attrs(bus);
+       klist_init(&bus->klist_drivers, NULL, NULL);
+
+       bus->drivers_autoprobe = 1;
+       retval = add_probe_files(bus);
+       if (retval)
+               goto bus_probe_files_fail;
+
+       retval = bus_add_attrs(bus);
+       if (retval)
+               goto bus_attrs_fail;
 
        pr_debug("bus type '%s' registered\n", bus->name);
        return 0;
 
+bus_attrs_fail:
+       remove_probe_files(bus);
+bus_probe_files_fail:
+       kset_unregister(&bus->drivers);
 bus_drivers_fail:
        kset_unregister(&bus->devices);
 bus_devices_fail:
@@ -657,7 +859,6 @@ out:
        return retval;
 }
 
-
 /**
  *     bus_unregister - remove a bus from the system
  *     @bus:   bus.
@@ -669,11 +870,24 @@ void bus_unregister(struct bus_type * bus)
 {
        pr_debug("bus %s: unregistering\n", bus->name);
        bus_remove_attrs(bus);
+       remove_probe_files(bus);
        kset_unregister(&bus->drivers);
        kset_unregister(&bus->devices);
        subsystem_unregister(&bus->subsys);
 }
 
+int bus_register_notifier(struct bus_type *bus, struct notifier_block *nb)
+{
+       return blocking_notifier_chain_register(&bus->bus_notifier, nb);
+}
+EXPORT_SYMBOL_GPL(bus_register_notifier);
+
+int bus_unregister_notifier(struct bus_type *bus, struct notifier_block *nb)
+{
+       return blocking_notifier_chain_unregister(&bus->bus_notifier, nb);
+}
+EXPORT_SYMBOL_GPL(bus_unregister_notifier);
+
 int __init buses_init(void)
 {
        return subsystem_register(&bus_subsys);
@@ -684,14 +898,9 @@ EXPORT_SYMBOL_GPL(bus_for_each_dev);
 EXPORT_SYMBOL_GPL(bus_find_device);
 EXPORT_SYMBOL_GPL(bus_for_each_drv);
 
-EXPORT_SYMBOL_GPL(bus_add_device);
-EXPORT_SYMBOL_GPL(bus_remove_device);
 EXPORT_SYMBOL_GPL(bus_register);
 EXPORT_SYMBOL_GPL(bus_unregister);
 EXPORT_SYMBOL_GPL(bus_rescan_devices);
-EXPORT_SYMBOL_GPL(get_bus);
-EXPORT_SYMBOL_GPL(put_bus);
-EXPORT_SYMBOL_GPL(find_bus);
 
 EXPORT_SYMBOL_GPL(bus_create_file);
 EXPORT_SYMBOL_GPL(bus_remove_file);