Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-2.6
Linus Torvalds [Thu, 5 Jan 2006 02:44:12 +0000 (18:44 -0800)]
Trivial manual merge fixup for usb_find_interface clashes.

1  2 
MAINTAINERS
drivers/scsi/ipr.c
drivers/usb/core/usb.c
include/linux/sysctl.h
include/linux/usb.h
init/Kconfig

diff --combined MAINTAINERS
@@@ -650,11 -650,6 +650,11 @@@ L:       linux-crypto@vger.kernel.or
  T:    git kernel.org:/pub/scm/linux/kernel/git/herbert/crypto-2.6.git
  S:    Maintained
  
 +CS5535 Audio ALSA driver
 +P:    Jaya Kumar
 +M:    jayakumar.alsa@gmail.com
 +S:    Maintained
 +
  CYBERPRO FB DRIVER
  P:    Russell King
  M:    rmk@arm.linux.org.uk
@@@ -1470,6 -1465,7 +1470,6 @@@ P:      Severa
  L:    kernel-janitors@osdl.org
  W:    http://www.kerneljanitors.org/
  W:    http://sf.net/projects/kernel-janitor/
 -W:    http://developer.osdl.org/rddunlap/kj-patches/
  S:    Maintained
  
  KERNEL NFSD
@@@ -1480,17 -1476,11 +1480,11 @@@ W:   http://nfs.sourceforge.net
  W:    http://www.cse.unsw.edu.au/~neilb/patches/linux-devel/
  S:    Maintained
  
- KERNEL EVENT LAYER (KOBJECT_UEVENT)
- P:    Robert Love
- M:    rml@novell.com
- L:    linux-kernel@vger.kernel.org
- S:    Maintained
  KEXEC
  P:    Eric Biederman
  P:    Randy Dunlap
  M:    ebiederm@xmission.com
 -M:    rddunlap@osdl.org
 +M:    rdunlap@xenotime.net
  W:    http://www.xmission.com/~ebiederm/files/kexec/
  L:    linux-kernel@vger.kernel.org
  L:    fastboot@osdl.org
@@@ -2591,6 -2581,7 +2585,6 @@@ S:      Maintaine
  UDF FILESYSTEM
  P:    Ben Fennema
  M:    bfennema@falcon.csc.calpoly.edu
 -L:    linux_udf@hpesjro.fc.hp.com
  W:    http://linux-udf.sourceforge.net
  S:    Maintained
  
@@@ -2643,12 -2634,6 +2637,12 @@@ L:    linux-usb-users@lists.sourceforge.ne
  L:    linux-usb-devel@lists.sourceforge.net
  S:    Maintained
  
 +USB ISP116X DRIVER
 +P:    Olav Kongas
 +M:    ok@artecdesign.ee
 +L:    linux-usb-devel@lists.sourceforge.net
 +S:    Maintained
 +
  USB KAWASAKI LSI DRIVER
  P:    Oliver Neukum
  M:    oliver@neukum.name
@@@ -2660,7 -2645,7 +2654,7 @@@ USB MASS STORAGE DRIVE
  P:    Matthew Dharm
  M:    mdharm-usb@one-eyed-alien.net
  L:    linux-usb-users@lists.sourceforge.net
 -L:    linux-usb-devel@lists.sourceforge.net
 +L:    usb-storage@lists.one-eyed-alien.net
  S:    Maintained
  W:    http://www.one-eyed-alien.net/~mdharm/linux-usb/
  
diff --combined drivers/scsi/ipr.c
@@@ -2132,7 -2132,7 +2132,7 @@@ restart
        }
  
        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-       kobject_uevent(&ioa_cfg->host->shost_classdev.kobj, KOBJ_CHANGE, NULL);
+       kobject_uevent(&ioa_cfg->host->shost_classdev.kobj, KOBJ_CHANGE);
        LEAVE;
  }
  
@@@ -5887,12 -5887,7 +5887,12 @@@ static int __devinit ipr_probe_ioa_part
        ENTER;
        spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
        dev_dbg(&ioa_cfg->pdev->dev, "ioa_cfg adx: 0x%p\n", ioa_cfg);
 -      _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_enable_ioa, IPR_SHUTDOWN_NONE);
 +      if (ioa_cfg->needs_hard_reset) {
 +              ioa_cfg->needs_hard_reset = 0;
 +              ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
 +      } else
 +              _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_enable_ioa,
 +                                      IPR_SHUTDOWN_NONE);
  
        spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
        wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
@@@ -6269,7 -6264,6 +6269,7 @@@ static int __devinit ipr_probe_ioa(stru
        unsigned long ipr_regs_pci;
        void __iomem *ipr_regs;
        u32 rc = PCIBIOS_SUCCESSFUL;
 +      volatile u32 mask, uproc;
  
        ENTER;
  
                goto cleanup_nomem;
        }
  
 +      /*
 +       * If HRRQ updated interrupt is not masked, or reset alert is set,
 +       * the card is in an unknown state and needs a hard reset
 +       */
 +      mask = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
 +      uproc = readl(ioa_cfg->regs.sense_uproc_interrupt_reg);
 +      if ((mask & IPR_PCII_HRRQ_UPDATED) == 0 || (uproc & IPR_UPROCI_RESET_ALERT))
 +              ioa_cfg->needs_hard_reset = 1;
 +
        ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
        rc = request_irq(pdev->irq, ipr_isr, SA_SHIRQ, IPR_NAME, ioa_cfg);
  
diff --combined drivers/usb/core/usb.c
@@@ -32,6 -32,7 +32,6 @@@
  #include <linux/spinlock.h>
  #include <linux/errno.h>
  #include <linux/smp_lock.h>
 -#include <linux/rwsem.h>
  #include <linux/usb.h>
  
  #include <asm/io.h>
  const char *usbcore_name = "usbcore";
  
  static int nousb;     /* Disable USB when built into kernel image */
 -                      /* Not honored on modular build */
  
 -static DECLARE_RWSEM(usb_all_devices_rwsem);
 -
 -
 -static int generic_probe (struct device *dev)
 -{
 -      return 0;
 -}
 -static int generic_remove (struct device *dev)
 -{
 -      struct usb_device *udev = to_usb_device(dev);
 -
 -      /* if this is only an unbind, not a physical disconnect, then
 -       * unconfigure the device */
 -      if (udev->state == USB_STATE_CONFIGURED)
 -              usb_set_configuration(udev, 0);
 -
 -      /* in case the call failed or the device was suspended */
 -      if (udev->state >= USB_STATE_CONFIGURED)
 -              usb_disable_device(udev, 0);
 -      return 0;
 -}
 -
 -static struct device_driver usb_generic_driver = {
 -      .owner = THIS_MODULE,
 -      .name = "usb",
 -      .bus = &usb_bus_type,
 -      .probe = generic_probe,
 -      .remove = generic_remove,
 -};
 -
 -static int usb_generic_driver_data;
 -
 -/* called from driver core with usb_bus_type.subsys writelock */
 -static int usb_probe_interface(struct device *dev)
 -{
 -      struct usb_interface * intf = to_usb_interface(dev);
 -      struct usb_driver * driver = to_usb_driver(dev->driver);
 -      const struct usb_device_id *id;
 -      int error = -ENODEV;
 -
 -      dev_dbg(dev, "%s\n", __FUNCTION__);
 -
 -      if (!driver->probe)
 -              return error;
 -      /* FIXME we'd much prefer to just resume it ... */
 -      if (interface_to_usbdev(intf)->state == USB_STATE_SUSPENDED)
 -              return -EHOSTUNREACH;
 -
 -      id = usb_match_id (intf, driver->id_table);
 -      if (id) {
 -              dev_dbg (dev, "%s - got id\n", __FUNCTION__);
 -
 -              /* Interface "power state" doesn't correspond to any hardware
 -               * state whatsoever.  We use it to record when it's bound to
 -               * a driver that may start I/0:  it's not frozen/quiesced.
 -               */
 -              mark_active(intf);
 -              intf->condition = USB_INTERFACE_BINDING;
 -              error = driver->probe (intf, id);
 -              if (error) {
 -                      mark_quiesced(intf);
 -                      intf->condition = USB_INTERFACE_UNBOUND;
 -              } else
 -                      intf->condition = USB_INTERFACE_BOUND;
 -      }
 -
 -      return error;
 -}
 -
 -/* called from driver core with usb_bus_type.subsys writelock */
 -static int usb_unbind_interface(struct device *dev)
 -{
 -      struct usb_interface *intf = to_usb_interface(dev);
 -      struct usb_driver *driver = to_usb_driver(intf->dev.driver);
 -
 -      intf->condition = USB_INTERFACE_UNBINDING;
 -
 -      /* release all urbs for this interface */
 -      usb_disable_interface(interface_to_usbdev(intf), intf);
 -
 -      if (driver && driver->disconnect)
 -              driver->disconnect(intf);
 -
 -      /* reset other interface state */
 -      usb_set_interface(interface_to_usbdev(intf),
 -                      intf->altsetting[0].desc.bInterfaceNumber,
 -                      0);
 -      usb_set_intfdata(intf, NULL);
 -      intf->condition = USB_INTERFACE_UNBOUND;
 -      mark_quiesced(intf);
 -
 -      return 0;
 -}
 -
 -/**
 - * usb_register - register a USB driver
 - * @new_driver: USB operations for the driver
 - *
 - * Registers a USB driver with the USB core.  The list of unattached
 - * interfaces will be rescanned whenever a new driver is added, allowing
 - * the new driver to attach to any recognized devices.
 - * Returns a negative error code on failure and 0 on success.
 - * 
 - * NOTE: if you want your driver to use the USB major number, you must call
 - * usb_register_dev() to enable that functionality.  This function no longer
 - * takes care of that.
 - */
 -int usb_register(struct usb_driver *new_driver)
 -{
 -      int retval = 0;
 -
 -      if (nousb)
 -              return -ENODEV;
 -
 -      new_driver->driver.name = (char *)new_driver->name;
 -      new_driver->driver.bus = &usb_bus_type;
 -      new_driver->driver.probe = usb_probe_interface;
 -      new_driver->driver.remove = usb_unbind_interface;
 -      new_driver->driver.owner = new_driver->owner;
 -
 -      usb_lock_all_devices();
 -      retval = driver_register(&new_driver->driver);
 -      usb_unlock_all_devices();
 -
 -      if (!retval) {
 -              pr_info("%s: registered new driver %s\n",
 -                      usbcore_name, new_driver->name);
 -              usbfs_update_special();
 -      } else {
 -              printk(KERN_ERR "%s: error %d registering driver %s\n",
 -                      usbcore_name, retval, new_driver->name);
 -      }
 -
 -      return retval;
 -}
 -
 -/**
 - * usb_deregister - unregister a USB driver
 - * @driver: USB operations of the driver to unregister
 - * Context: must be able to sleep
 - *
 - * Unlinks the specified driver from the internal USB driver list.
 - * 
 - * NOTE: If you called usb_register_dev(), you still need to call
 - * usb_deregister_dev() to clean up your driver's allocated minor numbers,
 - * this * call will no longer do it for you.
 - */
 -void usb_deregister(struct usb_driver *driver)
 -{
 -      pr_info("%s: deregistering driver %s\n", usbcore_name, driver->name);
 -
 -      usb_lock_all_devices();
 -      driver_unregister (&driver->driver);
 -      usb_unlock_all_devices();
 -
 -      usbfs_update_special();
 -}
  
  /**
   * usb_ifnum_to_if - get the interface object with a given interface number
@@@ -192,23 -351,151 +192,24 @@@ void usb_driver_release_interface(struc
        iface->condition = USB_INTERFACE_UNBOUND;
        mark_quiesced(iface);
  }
 -/**
 - * usb_match_id - find first usb_device_id matching device or interface
 - * @interface: the interface of interest
 - * @id: array of usb_device_id structures, terminated by zero entry
 - *
 - * usb_match_id searches an array of usb_device_id's and returns
 - * the first one matching the device or interface, or null.
 - * This is used when binding (or rebinding) a driver to an interface.
 - * Most USB device drivers will use this indirectly, through the usb core,
 - * but some layered driver frameworks use it directly.
 - * These device tables are exported with MODULE_DEVICE_TABLE, through
 - * modutils, to support the driver loading functionality of USB hotplugging.
 - *
 - * What Matches:
 - *
 - * The "match_flags" element in a usb_device_id controls which
 - * members are used.  If the corresponding bit is set, the
 - * value in the device_id must match its corresponding member
 - * in the device or interface descriptor, or else the device_id
 - * does not match.
 - *
 - * "driver_info" is normally used only by device drivers,
 - * but you can create a wildcard "matches anything" usb_device_id
 - * as a driver's "modules.usbmap" entry if you provide an id with
 - * only a nonzero "driver_info" field.  If you do this, the USB device
 - * driver's probe() routine should use additional intelligence to
 - * decide whether to bind to the specified interface.
 - * 
 - * What Makes Good usb_device_id Tables:
 - *
 - * The match algorithm is very simple, so that intelligence in
 - * driver selection must come from smart driver id records.
 - * Unless you have good reasons to use another selection policy,
 - * provide match elements only in related groups, and order match
 - * specifiers from specific to general.  Use the macros provided
 - * for that purpose if you can.
 - *
 - * The most specific match specifiers use device descriptor
 - * data.  These are commonly used with product-specific matches;
 - * the USB_DEVICE macro lets you provide vendor and product IDs,
 - * and you can also match against ranges of product revisions.
 - * These are widely used for devices with application or vendor
 - * specific bDeviceClass values.
 - *
 - * Matches based on device class/subclass/protocol specifications
 - * are slightly more general; use the USB_DEVICE_INFO macro, or
 - * its siblings.  These are used with single-function devices
 - * where bDeviceClass doesn't specify that each interface has
 - * its own class. 
 - *
 - * Matches based on interface class/subclass/protocol are the
 - * most general; they let drivers bind to any interface on a
 - * multiple-function device.  Use the USB_INTERFACE_INFO
 - * macro, or its siblings, to match class-per-interface style 
 - * devices (as recorded in bDeviceClass).
 - *  
 - * Within those groups, remember that not all combinations are
 - * meaningful.  For example, don't give a product version range
 - * without vendor and product IDs; or specify a protocol without
 - * its associated class and subclass.
 - */   
 -const struct usb_device_id *
 -usb_match_id(struct usb_interface *interface, const struct usb_device_id *id)
 -{
 -      struct usb_host_interface *intf;
 -      struct usb_device *dev;
 -
 -      /* proc_connectinfo in devio.c may call us with id == NULL. */
 -      if (id == NULL)
 -              return NULL;
 -
 -      intf = interface->cur_altsetting;
 -      dev = interface_to_usbdev(interface);
 -
 -      /* It is important to check that id->driver_info is nonzero,
 -         since an entry that is all zeroes except for a nonzero
 -         id->driver_info is the way to create an entry that
 -         indicates that the driver want to examine every
 -         device and interface. */
 -      for (; id->idVendor || id->bDeviceClass || id->bInterfaceClass ||
 -             id->driver_info; id++) {
 -
 -              if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
 -                  id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
 -                      continue;
 -
 -              if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
 -                  id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
 -                      continue;
 -
 -              /* No need to test id->bcdDevice_lo != 0, since 0 is never
 -                 greater than any unsigned number. */
 -              if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
 -                  (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
 -                      continue;
 -
 -              if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
 -                  (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
 -                      continue;
 -
 -              if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
 -                  (id->bDeviceClass != dev->descriptor.bDeviceClass))
 -                      continue;
 -
 -              if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
 -                  (id->bDeviceSubClass!= dev->descriptor.bDeviceSubClass))
 -                      continue;
 -
 -              if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
 -                  (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
 -                      continue;
 -
 -              if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
 -                  (id->bInterfaceClass != intf->desc.bInterfaceClass))
 -                      continue;
 -
 -              if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
 -                  (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
 -                      continue;
 -
 -              if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
 -                  (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
 -                      continue;
 -
 -              return id;
 -      }
 -
 -      return NULL;
 -}
 -
 +struct find_interface_arg {
 +      int minor;
 +      struct usb_interface *interface;
 +};
  
  static int __find_interface(struct device * dev, void * data)
  {
 -      struct usb_interface ** ret = (struct usb_interface **)data;
 -      struct usb_interface * intf = *ret;
 -      int *minor = (int *)data;
 +      struct find_interface_arg *arg = data;
 +      struct usb_interface *intf;
  
        /* can't look at usb devices, only interfaces */
        if (dev->driver == &usb_generic_driver)
                return 0;
  
        intf = to_usb_interface(dev);
 -      if (intf->minor != -1 && intf->minor == *minor) {
 -              *ret = intf;
 +      if (intf->minor != -1 && intf->minor == arg->minor) {
 +              arg->interface = intf;
                return 1;
        }
        return 0;
   */
  struct usb_interface *usb_find_interface(struct usb_driver *drv, int minor)
  {
 -      struct usb_interface *intf = (struct usb_interface *)(long)minor;
 -      int ret;
 -
 -      ret = driver_for_each_device(&drv->driver, NULL, &intf, __find_interface);
 -
 -      return ret ? intf : NULL;
 -}
 -
 -static int usb_device_match (struct device *dev, struct device_driver *drv)
 -{
 -      struct usb_interface *intf;
 -      struct usb_driver *usb_drv;
 -      const struct usb_device_id *id;
 -
 -      /* check for generic driver, which we don't match any device with */
 -      if (drv == &usb_generic_driver)
 -              return 0;
 -
 -      intf = to_usb_interface(dev);
 -      usb_drv = to_usb_driver(drv);
 -      
 -      id = usb_match_id (intf, usb_drv->id_table);
 -      if (id)
 -              return 1;
 +      struct find_interface_arg argb;
  
 -      return 0;
 +      argb.minor = minor;
 +      argb.interface = NULL;
 +      driver_for_each_device(&drv->driver, NULL, &argb, __find_interface);
 +      return argb.interface;
  }
  
  #ifdef        CONFIG_HOTPLUG
  
  /*
-  * USB hotplugging invokes what /proc/sys/kernel/hotplug says
-  * (normally /sbin/hotplug) when USB devices get added or removed.
-  *
-  * This invokes a user mode policy agent, typically helping to load driver
+  * This sends an uevent to userspace, typically helping to load driver
   * or other modules, configure the device, and more.  Drivers can provide
   * a MODULE_DEVICE_TABLE to help with module loading subtasks.
   *
   * delays in event delivery.  Use sysfs (and DEVPATH) to make sure the
   * device (and this configuration!) are still present.
   */
- static int usb_hotplug (struct device *dev, char **envp, int num_envp,
-                       char *buffer, int buffer_size)
+ static int usb_uevent(struct device *dev, char **envp, int num_envp,
+                     char *buffer, int buffer_size)
  {
        struct usb_interface *intf;
        struct usb_device *usb_dev;
                return -ENODEV;
  
        /* driver is often null here; dev_dbg() would oops */
-       pr_debug ("usb %s: hotplug\n", dev->bus_id);
+       pr_debug ("usb %s: uevent\n", dev->bus_id);
  
        /* Must check driver_data here, as on remove driver is always NULL */
        if ((dev->driver == &usb_generic_driver) || 
         *
         * FIXME reduce hardwired intelligence here
         */
-       if (add_hotplug_env_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "DEVICE=/proc/bus/usb/%03d/%03d",
-                               usb_dev->bus->busnum, usb_dev->devnum))
+       if (add_uevent_var(envp, num_envp, &i,
+                          buffer, buffer_size, &length,
+                          "DEVICE=/proc/bus/usb/%03d/%03d",
+                          usb_dev->bus->busnum, usb_dev->devnum))
                return -ENOMEM;
  #endif
  
        /* per-device configurations are common */
-       if (add_hotplug_env_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "PRODUCT=%x/%x/%x",
-                               le16_to_cpu(usb_dev->descriptor.idVendor),
-                               le16_to_cpu(usb_dev->descriptor.idProduct),
-                               le16_to_cpu(usb_dev->descriptor.bcdDevice)))
+       if (add_uevent_var(envp, num_envp, &i,
+                          buffer, buffer_size, &length,
+                          "PRODUCT=%x/%x/%x",
+                          le16_to_cpu(usb_dev->descriptor.idVendor),
+                          le16_to_cpu(usb_dev->descriptor.idProduct),
+                          le16_to_cpu(usb_dev->descriptor.bcdDevice)))
                return -ENOMEM;
  
        /* class-based driver binding models */
-       if (add_hotplug_env_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "TYPE=%d/%d/%d",
-                               usb_dev->descriptor.bDeviceClass,
-                               usb_dev->descriptor.bDeviceSubClass,
-                               usb_dev->descriptor.bDeviceProtocol))
+       if (add_uevent_var(envp, num_envp, &i,
+                          buffer, buffer_size, &length,
+                          "TYPE=%d/%d/%d",
+                          usb_dev->descriptor.bDeviceClass,
+                          usb_dev->descriptor.bDeviceSubClass,
+                          usb_dev->descriptor.bDeviceProtocol))
                return -ENOMEM;
  
-       if (add_hotplug_env_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "INTERFACE=%d/%d/%d",
-                               alt->desc.bInterfaceClass,
-                               alt->desc.bInterfaceSubClass,
-                               alt->desc.bInterfaceProtocol))
+       if (add_uevent_var(envp, num_envp, &i,
+                          buffer, buffer_size, &length,
+                          "INTERFACE=%d/%d/%d",
+                          alt->desc.bInterfaceClass,
+                          alt->desc.bInterfaceSubClass,
+                          alt->desc.bInterfaceProtocol))
                return -ENOMEM;
  
-       if (add_hotplug_env_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "MODALIAS=usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02X",
-                               le16_to_cpu(usb_dev->descriptor.idVendor),
-                               le16_to_cpu(usb_dev->descriptor.idProduct),
-                               le16_to_cpu(usb_dev->descriptor.bcdDevice),
-                               usb_dev->descriptor.bDeviceClass,
-                               usb_dev->descriptor.bDeviceSubClass,
-                               usb_dev->descriptor.bDeviceProtocol,
-                               alt->desc.bInterfaceClass,
-                               alt->desc.bInterfaceSubClass,
-                               alt->desc.bInterfaceProtocol))
+       if (add_uevent_var(envp, num_envp, &i,
+                          buffer, buffer_size, &length,
+                          "MODALIAS=usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02X",
+                          le16_to_cpu(usb_dev->descriptor.idVendor),
+                          le16_to_cpu(usb_dev->descriptor.idProduct),
+                          le16_to_cpu(usb_dev->descriptor.bcdDevice),
+                          usb_dev->descriptor.bDeviceClass,
+                          usb_dev->descriptor.bDeviceSubClass,
+                          usb_dev->descriptor.bDeviceProtocol,
+                          alt->desc.bInterfaceClass,
+                          alt->desc.bInterfaceSubClass,
+                          alt->desc.bInterfaceProtocol))
                return -ENOMEM;
  
        envp[i] = NULL;
  
  #else
  
- static int usb_hotplug (struct device *dev, char **envp,
+ static int usb_uevent(struct device *dev, char **envp,
                        int num_envp, char *buffer, int buffer_size)
  {
        return -ENODEV;
@@@ -441,11 -746,12 +439,11 @@@ usb_alloc_dev(struct usb_device *parent
                /* hub driver sets up TT records */
        }
  
 +      dev->portnum = port1;
        dev->bus = bus;
        dev->parent = parent;
        INIT_LIST_HEAD(&dev->filelist);
  
 -      init_MUTEX(&dev->serialize);
 -
        return dev;
  }
  
@@@ -518,21 -824,76 +516,21 @@@ void usb_put_intf(struct usb_interface 
  
  /*                    USB device locking
   *
 - * Although locking USB devices should be straightforward, it is
 - * complicated by the way the driver-model core works.  When a new USB
 - * driver is registered or unregistered, the core will automatically
 - * probe or disconnect all matching interfaces on all USB devices while
 - * holding the USB subsystem writelock.  There's no good way for us to
 - * tell which devices will be used or to lock them beforehand; our only
 - * option is to effectively lock all the USB devices.
 - *
 - * We do that by using a private rw-semaphore, usb_all_devices_rwsem.
 - * When locking an individual device you must first acquire the rwsem's
 - * readlock.  When a driver is registered or unregistered the writelock
 - * must be held.  These actions are encapsulated in the subroutines
 - * below, so all a driver needs to do is call usb_lock_device() and
 - * usb_unlock_device().
 + * USB devices and interfaces are locked using the semaphore in their
 + * embedded struct device.  The hub driver guarantees that whenever a
 + * device is connected or disconnected, drivers are called with the
 + * USB device locked as well as their particular interface.
   *
   * Complications arise when several devices are to be locked at the same
   * time.  Only hub-aware drivers that are part of usbcore ever have to
 - * do this; nobody else needs to worry about it.  The problem is that
 - * usb_lock_device() must not be called to lock a second device since it
 - * would acquire the rwsem's readlock reentrantly, leading to deadlock if
 - * another thread was waiting for the writelock.  The solution is simple:
 - *
 - *    When locking more than one device, call usb_lock_device()
 - *    to lock the first one.  Lock the others by calling
 - *    down(&udev->serialize) directly.
 - *
 - *    When unlocking multiple devices, use up(&udev->serialize)
 - *    to unlock all but the last one.  Unlock the last one by
 - *    calling usb_unlock_device().
 + * do this; nobody else needs to worry about it.  The rule for locking
 + * is simple:
   *
   *    When locking both a device and its parent, always lock the
   *    the parent first.
   */
  
  /**
 - * usb_lock_device - acquire the lock for a usb device structure
 - * @udev: device that's being locked
 - *
 - * Use this routine when you don't hold any other device locks;
 - * to acquire nested inner locks call down(&udev->serialize) directly.
 - * This is necessary for proper interaction with usb_lock_all_devices().
 - */
 -void usb_lock_device(struct usb_device *udev)
 -{
 -      down_read(&usb_all_devices_rwsem);
 -      down(&udev->serialize);
 -}
 -
 -/**
 - * usb_trylock_device - attempt to acquire the lock for a usb device structure
 - * @udev: device that's being locked
 - *
 - * Don't use this routine if you already hold a device lock;
 - * use down_trylock(&udev->serialize) instead.
 - * This is necessary for proper interaction with usb_lock_all_devices().
 - *
 - * Returns 1 if successful, 0 if contention.
 - */
 -int usb_trylock_device(struct usb_device *udev)
 -{
 -      if (!down_read_trylock(&usb_all_devices_rwsem))
 -              return 0;
 -      if (down_trylock(&udev->serialize)) {
 -              up_read(&usb_all_devices_rwsem);
 -              return 0;
 -      }
 -      return 1;
 -}
 -
 -/**
   * usb_lock_device_for_reset - cautiously acquire the lock for a
   *    usb device structure
   * @udev: device that's being locked
@@@ -570,7 -931,7 +568,7 @@@ int usb_lock_device_for_reset(struct us
                }
        }
  
 -      while (!usb_trylock_device(udev)) {
 +      while (usb_trylock_device(udev) != 0) {
  
                /* If we can't acquire the lock after waiting one second,
                 * we're probably deadlocked */
        return 1;
  }
  
 -/**
 - * usb_unlock_device - release the lock for a usb device structure
 - * @udev: device that's being unlocked
 - *
 - * Use this routine when releasing the only device lock you hold;
 - * to release inner nested locks call up(&udev->serialize) directly.
 - * This is necessary for proper interaction with usb_lock_all_devices().
 - */
 -void usb_unlock_device(struct usb_device *udev)
 -{
 -      up(&udev->serialize);
 -      up_read(&usb_all_devices_rwsem);
 -}
 -
 -/**
 - * usb_lock_all_devices - acquire the lock for all usb device structures
 - *
 - * This is necessary when registering a new driver or probing a bus,
 - * since the driver-model core may try to use any usb_device.
 - */
 -void usb_lock_all_devices(void)
 -{
 -      down_write(&usb_all_devices_rwsem);
 -}
 -
 -/**
 - * usb_unlock_all_devices - release the lock for all usb device structures
 - */
 -void usb_unlock_all_devices(void)
 -{
 -      up_write(&usb_all_devices_rwsem);
 -}
 -
  
  static struct usb_device *match_device(struct usb_device *dev,
                                       u16 vendor_id, u16 product_id)
        /* look through all of the children of this device */
        for (child = 0; child < dev->maxchild; ++child) {
                if (dev->children[child]) {
 -                      down(&dev->children[child]->serialize);
 +                      usb_lock_device(dev->children[child]);
                        ret_dev = match_device(dev->children[child],
                                               vendor_id, product_id);
 -                      up(&dev->children[child]->serialize);
 +                      usb_unlock_device(dev->children[child]);
                        if (ret_dev)
                                goto exit;
                }
@@@ -1093,13 -1487,23 +1091,13 @@@ static int usb_generic_resume(struct de
  struct bus_type usb_bus_type = {
        .name =         "usb",
        .match =        usb_device_match,
-       .hotplug =      usb_hotplug,
+       .uevent =       usb_uevent,
        .suspend =      usb_generic_suspend,
        .resume =       usb_generic_resume,
  };
  
 -#ifndef MODULE
 -
 -static int __init usb_setup_disable(char *str)
 -{
 -      nousb = 1;
 -      return 1;
 -}
 -
  /* format to disable USB on kernel command line is: nousb */
 -__setup("nousb", usb_setup_disable);
 -
 -#endif
 +__module_param_call("", nousb, param_set_bool, param_get_bool, &nousb, 0444);
  
  /*
   * for external read access to <nousb>
@@@ -1190,6 -1594,8 +1188,6 @@@ module_exit(usb_exit)
   * driver modules to use.
   */
  
 -EXPORT_SYMBOL(usb_register);
 -EXPORT_SYMBOL(usb_deregister);
  EXPORT_SYMBOL(usb_disabled);
  
  EXPORT_SYMBOL_GPL(usb_get_intf);
@@@ -1200,10 -1606,14 +1198,10 @@@ EXPORT_SYMBOL(usb_put_dev)
  EXPORT_SYMBOL(usb_get_dev);
  EXPORT_SYMBOL(usb_hub_tt_clear_buffer);
  
 -EXPORT_SYMBOL(usb_lock_device);
 -EXPORT_SYMBOL(usb_trylock_device);
  EXPORT_SYMBOL(usb_lock_device_for_reset);
  
  EXPORT_SYMBOL(usb_driver_claim_interface);
  EXPORT_SYMBOL(usb_driver_release_interface);
 -EXPORT_SYMBOL(usb_match_id);
  EXPORT_SYMBOL(usb_find_interface);
  EXPORT_SYMBOL(usb_ifnum_to_if);
  EXPORT_SYMBOL(usb_altnum_to_altsetting);
diff --combined include/linux/sysctl.h
@@@ -124,7 -124,7 +124,7 @@@ enu
        KERN_OVERFLOWUID=46,    /* int: overflow UID */
        KERN_OVERFLOWGID=47,    /* int: overflow GID */
        KERN_SHMPATH=48,        /* string: path to shm fs */
-       KERN_HOTPLUG=49,        /* string: path to hotplug policy agent */
+       KERN_HOTPLUG=49,        /* string: path to uevent helper (deprecated) */
        KERN_IEEE_EMULATION_WARNINGS=50, /* int: unimplemented ieee instructions */
        KERN_S390_USER_DEBUG_LOGGING=51,  /* int: dumps of user faults */
        KERN_CORE_USES_PID=52,          /* int: use core or core.%pid */
@@@ -390,7 -390,6 +390,7 @@@ enu
        NET_IPV4_ICMP_ERRORS_USE_INBOUND_IFADDR=109,
        NET_TCP_CONG_CONTROL=110,
        NET_TCP_ABC=111,
 +      NET_IPV4_IPFRAG_MAX_DIST=112,
  };
  
  enum {
diff --combined include/linux/usb.h
@@@ -225,7 -225,7 +225,7 @@@ struct usb_interface_cache 
   * Device drivers should not attempt to activate configurations.  The choice
   * of which configuration to install is a policy decision based on such
   * considerations as available power, functionality provided, and the user's
-  * desires (expressed through hotplug scripts).  However, drivers can call
+  * desires (expressed through userspace tools).  However, drivers can call
   * usb_reset_configuration() to reinitialize the current configuration and
   * all its interfaces.
   */
@@@ -329,6 -329,8 +329,6 @@@ struct usb_device 
        struct usb_tt   *tt;            /* low/full speed dev, highspeed hub */
        int             ttport;         /* device port on that tt hub */
  
 -      struct semaphore serialize;
 -
        unsigned int toggle[2];         /* one bit for each endpoint
                                         * ([0] = IN, [1] = OUT) */
  
  
        char **rawdescriptors;          /* Raw descriptors for each config */
  
 +      unsigned short bus_mA;          /* Current available from the bus */
 +      u8 portnum;                     /* Parent port number (origin 1) */
 +
        int have_langid;                /* whether string_langid is valid */
        int string_langid;              /* language ID for strings */
  
  extern struct usb_device *usb_get_dev(struct usb_device *dev);
  extern void usb_put_dev(struct usb_device *dev);
  
 -extern void usb_lock_device(struct usb_device *udev);
 -extern int usb_trylock_device(struct usb_device *udev);
 +/* USB device locking */
 +#define usb_lock_device(udev)         down(&(udev)->dev.sem)
 +#define usb_unlock_device(udev)               up(&(udev)->dev.sem)
 +#define usb_trylock_device(udev)      down_trylock(&(udev)->dev.sem)
  extern int usb_lock_device_for_reset(struct usb_device *udev,
                struct usb_interface *iface);
 -extern void usb_unlock_device(struct usb_device *udev);
  
  /* USB port reset for device reinitialization */
  extern int usb_reset_device(struct usb_device *dev);
@@@ -531,13 -529,10 +531,13 @@@ static inline int usb_make_path (struc
  
  /* ----------------------------------------------------------------------- */
  
 +struct usb_dynids {
 +      spinlock_t lock;
 +      struct list_head list;
 +};
 +
  /**
   * struct usb_driver - identifies USB driver to usbcore
 - * @owner: Pointer to the module owner of this driver; initialize
 - *    it using THIS_MODULE.
   * @name: The driver name should be unique among USB drivers,
   *    and should normally be the same as the module name.
   * @probe: Called to see if the driver is willing to manage a particular
   * @id_table: USB drivers use ID table to support hotplugging.
   *    Export this with MODULE_DEVICE_TABLE(usb,...).  This must be set
   *    or your driver's probe function will never get called.
 + * @dynids: used internally to hold the list of dynamically added device
 + *    ids for this driver.
   * @driver: the driver model core driver structure.
 + * @no_dynamic_id: if set to 1, the USB core will not allow dynamic ids to be
 + *    added to this driver by preventing the sysfs file from being created.
   *
   * USB drivers must provide a name, probe() and disconnect() methods,
   * and an id_table.  Other driver fields are optional.
   * them as necessary, and blocking until the unlinks complete).
   */
  struct usb_driver {
 -      struct module *owner;
 -
        const char *name;
  
        int (*probe) (struct usb_interface *intf,
  
        const struct usb_device_id *id_table;
  
 +      struct usb_dynids dynids;
        struct device_driver driver;
 +      unsigned int no_dynamic_id:1;
  };
  #define       to_usb_driver(d) container_of(d, struct usb_driver, driver)
  
@@@ -623,11 -614,7 +623,11 @@@ struct usb_class_driver 
   * use these in module_init()/module_exit()
   * and don't forget MODULE_DEVICE_TABLE(usb, ...)
   */
 -extern int usb_register(struct usb_driver *);
 +int usb_register_driver(struct usb_driver *, struct module *);
 +static inline int usb_register(struct usb_driver *driver)
 +{
 +      return usb_register_driver(driver, THIS_MODULE);
 +}
  extern void usb_deregister(struct usb_driver *);
  
  extern int usb_register_dev(struct usb_interface *intf,
diff --combined init/Kconfig
@@@ -197,33 -197,6 +197,6 @@@ config AUDITSYSCAL
          can be used independently or with another kernel subsystem,
          such as SELinux.
  
- config HOTPLUG
-       bool "Support for hot-pluggable devices" if !ARCH_S390
-       default ARCH_S390
-       help
-         This option is provided for the case where no in-kernel-tree
-         modules require HOTPLUG functionality, but a module built
-         outside the kernel tree does. Such modules require Y here.
- config KOBJECT_UEVENT
-       bool "Kernel Userspace Events" if EMBEDDED
-       depends on NET
-       default y
-       help
-         This option enables the kernel userspace event layer, which is a
-         simple mechanism for kernel-to-user communication over a netlink
-         socket.
-         The goal of the kernel userspace events layer is to provide a simple
-         and efficient events system, that notifies userspace about kobject
-         state changes. This will enable applications to just listen for
-         events instead of polling system devices and files.
-         Hotplug events (kobject addition and removal) are also available on
-         the netlink socket in addition to the execution of /sbin/hotplug if
-         CONFIG_HOTPLUG is enabled.
-         Say Y, unless you are building a system requiring minimal memory
-         consumption.
  config IKCONFIG
        bool "Kernel .config support"
        ---help---
@@@ -308,6 -281,15 +281,15 @@@ config KALLSYMS_EXTRA_PAS
           you wait for kallsyms to be fixed.
  
  
+ config HOTPLUG
+       bool "Support for hot-pluggable devices" if EMBEDDED
+       default y
+       help
+         This option is provided for the case where no hotplug or uevent
+         capabilities is wanted by the kernel.  You should only consider
+         disabling this option for embedded systems that do not use modules, a
+         dynamic /dev tree, or dynamic device discovery.  Just say Y.
  config PRINTK
        default y
        bool "Enable support for printk" if EMBEDDED
@@@ -461,8 -443,8 +443,8 @@@ config OBSOLETE_MODPAR
          If unsure, say Y.
  
  config MODVERSIONS
 -      bool "Module versioning support (EXPERIMENTAL)"
 -      depends on MODULES && EXPERIMENTAL
 +      bool "Module versioning support"
 +      depends on MODULES
        help
          Usually, you have to use modules compiled with your kernel.
          Saying Y here makes it sometimes possible to use modules