Merge bk://kernel.bkbits.net//home/mochel/linux-2.5-power

into osdl.org:/home/mochel/src/kernel/linux-2.5-power

Documentation/i2c/sysfs-interface

@@ -78,6 +78,9 @@ curr_input[1-n]	Current input value
 		Fixed point XXXXX, divide by 1000 to get Amps.
 		Read only.
 
+eeprom		Raw EEPROM data in binary form.
+		Read only.
+
 fan_min[1-3]	Fan minimum value
 		Integer value indicating RPM
 		Read/Write.

drivers/block/ll_rw_blk.c

@@ -376,6 +376,11 @@ void blk_queue_hardsect_size(request_queue_t *q, unsigned short size)
 	q->hardsect_size = size;
 }
 
+/*
+ * Returns the minimum that is _not_ zero, unless both are zero.
+ */
+#define min_not_zero(l, r) (l == 0) ? r : ((r == 0) ? l : min(l, r))
+
 /**
  * blk_queue_stack_limits - inherit underlying queue limits for stacked drivers
  * @t:	the stacking driver (top)
@@ -383,7 +388,9 @@ void blk_queue_hardsect_size(request_queue_t *q, unsigned short size)
  **/
 void blk_queue_stack_limits(request_queue_t *t, request_queue_t *b)
 {
-	t->max_sectors = min(t->max_sectors,b->max_sectors);
+	/* zero is "infinity" */
+	t->max_sectors = min_not_zero(t->max_sectors,b->max_sectors);
+
 	t->max_phys_segments = min(t->max_phys_segments,b->max_phys_segments);
 	t->max_hw_segments = min(t->max_hw_segments,b->max_hw_segments);
 	t->max_segment_size = min(t->max_segment_size,b->max_segment_size);

drivers/i2c/Kconfig

@@ -37,43 +37,7 @@ config I2C_CHARDEV
 	  This support is also available as a module.  If so, the module 
 	  will be called i2c-dev.
 
-config I2C_ALGOBIT
-	tristate "I2C bit-banging interfaces"
-	depends on I2C
-	help
-	  This allows you to use a range of I2C adapters called bit-banging
-	  adapters.  Say Y if you own an I2C adapter belonging to this class
-	  and then say Y to the specific driver for you adapter below.
-
-	  This support is also available as a module.  If so, the module 
-	  will be called i2c-algo-bit.
-
-config I2C_ALGOPCF
-	tristate "I2C PCF 8584 interfaces"
-	depends on I2C
-	help
-	  This allows you to use a range of I2C adapters called PCF adapters.
-	  Say Y if you own an I2C adapter belonging to this class and then say
-	  Y to the specific driver for you adapter below.
-
-	  This support is also available as a module.  If so, the module 
-	  will be called i2c-algo-pcf.
-
-config I2C_ALGOITE
-	tristate "ITE I2C Algorithm"
-	depends on MIPS_ITE8172 && I2C
-	help
-	  This supports the use of the ITE8172 I2C interface found on some MIPS
-	  systems. Say Y if you have one of these. You should also say Y for
-	  the ITE I2C peripheral driver support below.
-
-	  This support is also available as a module.  If so, the module 
-	  will be called i2c-algo-ite.
-
-config I2C_ALGO8XX
-	tristate "MPC8xx CPM I2C interface"
-	depends on 8xx && I2C
-
+	source drivers/i2c/algos/Kconfig
 	source drivers/i2c/busses/Kconfig
 	source drivers/i2c/chips/Kconfig
 

drivers/i2c/Makefile

@@ -5,7 +5,4 @@
 obj-$(CONFIG_I2C)		+= i2c-core.o
 obj-$(CONFIG_I2C_CHARDEV)	+= i2c-dev.o
 obj-$(CONFIG_I2C_SENSOR)	+= i2c-sensor.o
-obj-$(CONFIG_I2C_ALGOBIT)	+= i2c-algo-bit.o
-obj-$(CONFIG_I2C_ALGOPCF)	+= i2c-algo-pcf.o
-obj-$(CONFIG_I2C_ALGOITE)	+= i2c-algo-ite.o
-obj-y				+= busses/ chips/
+obj-y				+= busses/ chips/ algos/

drivers/i2c/algos/Kconfig

+#
+# Character device configuration
+#
+
+menu "I2C Algorithms"
+
+config I2C_ALGOBIT
+	tristate "I2C bit-banging interfaces"
+	depends on I2C
+	help
+	  This allows you to use a range of I2C adapters called bit-banging
+	  adapters.  Say Y if you own an I2C adapter belonging to this class
+	  and then say Y to the specific driver for you adapter below.
+
+	  This support is also available as a module.  If so, the module 
+	  will be called i2c-algo-bit.
+
+config I2C_ALGOPCF
+	tristate "I2C PCF 8584 interfaces"
+	depends on I2C
+	help
+	  This allows you to use a range of I2C adapters called PCF adapters.
+	  Say Y if you own an I2C adapter belonging to this class and then say
+	  Y to the specific driver for you adapter below.
+
+	  This support is also available as a module.  If so, the module 
+	  will be called i2c-algo-pcf.
+
+config I2C_ALGOITE
+	tristate "ITE I2C Algorithm"
+	depends on MIPS_ITE8172 && I2C
+	help
+	  This supports the use of the ITE8172 I2C interface found on some MIPS
+	  systems. Say Y if you have one of these. You should also say Y for
+	  the ITE I2C peripheral driver support below.
+
+	  This support is also available as a module.  If so, the module 
+	  will be called i2c-algo-ite.
+
+config I2C_ALGO8XX
+	tristate "MPC8xx CPM I2C interface"
+	depends on 8xx && I2C
+
+endmenu
+

drivers/i2c/algos/Makefile

+#
+# Makefile for the i2c algorithms
+#
+
+obj-$(CONFIG_I2C_ALGOBIT)	+= i2c-algo-bit.o
+obj-$(CONFIG_I2C_ALGOPCF)	+= i2c-algo-pcf.o
+obj-$(CONFIG_I2C_ALGOITE)	+= i2c-algo-ite.o

drivers/i2c/i2c-algo-ite.c → drivers/i2c/algos/i2c-algo-ite.c

@@ -46,7 +46,7 @@
 
 #include <linux/i2c.h>
 #include <linux/i2c-algo-ite.h>
-#include "i2c-ite.h"
+#include "i2c-algo-ite.h"
 
 #define	PM_DSR		IT8172_PCI_IO_BASE + IT_PM_DSR
 #define	PM_IBSR		IT8172_PCI_IO_BASE + IT_PM_DSR + 0x04 

drivers/i2c/i2c-algo-pcf.c → drivers/i2c/algos/i2c-algo-pcf.c

@@ -37,7 +37,7 @@
 #include <linux/errno.h>
 #include <linux/i2c.h>
 #include <linux/i2c-algo-pcf.h>
-#include "i2c-pcf8584.h"
+#include "i2c-algo-pcf.h"
 
 
 /* ----- global defines ----------------------------------------------- */

drivers/i2c/busses/i2c-elektor.c

@@ -41,7 +41,7 @@
 #include <asm/io.h>
 #include <asm/irq.h>
 
-#include "../i2c-pcf8584.h"
+#include "../algos/i2c-algo-pcf.h"
 
 #define DEFAULT_BASE 0x330
 

drivers/i2c/chips/Kconfig

@@ -21,6 +21,18 @@ config SENSORS_ADM1021
 	  This driver can also be built as a module.  If so, the module
 	  will be called adm1021.
 
+config SENSORS_EEPROM
+	tristate "EEPROM (DIMM) reader"
+	depends on I2C && EXPERIMENTAL
+	select I2C_SENSOR
+	help
+	  If you say yes here you get read-only access to the EEPROM data
+	  available on modern memory DIMMs, and which could theoretically
+	  also be available on other devices.
+
+	  This driver can also be built as a module.  If so, the module
+	  will be called eeprom.
+
 config SENSORS_IT87
 	tristate "National Semiconductors IT87 and compatibles"
 	depends on I2C && EXPERIMENTAL

drivers/i2c/chips/Makefile

@@ -6,6 +6,7 @@
 obj-$(CONFIG_SENSORS_W83781D)	+= w83781d.o
 
 obj-$(CONFIG_SENSORS_ADM1021)	+= adm1021.o
+obj-$(CONFIG_SENSORS_EEPROM)	+= eeprom.o
 obj-$(CONFIG_SENSORS_IT87)	+= it87.o
 obj-$(CONFIG_SENSORS_LM75)	+= lm75.o
 obj-$(CONFIG_SENSORS_LM78)	+= lm78.o

drivers/i2c/chips/eeprom.c

+/*
+    eeprom.c - Part of lm_sensors, Linux kernel modules for hardware
+               monitoring
+    Copyright (C) 1998, 1999  Frodo Looijaard <frodol@dds.nl> and
+			       Philip Edelbrock <phil@netroedge.com>
+    Copyright (C) 2003 Greg Kroah-Hartman <greg@kroah.com>
+    Copyright (C) 2003 IBM Corp.
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* #define DEBUG */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-sensor.h>
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { I2C_CLIENT_END };
+static unsigned short normal_i2c_range[] = { 0x50, 0x57, I2C_CLIENT_END };
+static unsigned int normal_isa[] = { I2C_CLIENT_ISA_END };
+static unsigned int normal_isa_range[] = { I2C_CLIENT_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(eeprom);
+
+static int checksum = 0;
+MODULE_PARM(checksum, "i");
+MODULE_PARM_DESC(checksum, "Only accept eeproms whose checksum is correct");
+
+
+/* EEPROM registers */
+#define EEPROM_REG_CHECKSUM	0x3f
+
+/* Size of EEPROM in bytes */
+#define EEPROM_SIZE		256
+
+/* possible types of eeprom devices */
+enum eeprom_nature {
+	UNKNOWN,
+	VAIO,
+};
+
+/* Each client has this additional data */
+struct eeprom_data {
+	struct semaphore update_lock;
+	char valid;			/* !=0 if following fields are valid */
+	unsigned long last_updated;	/* In jiffies */
+	u8 data[EEPROM_SIZE];		/* Register values */
+};
+
+
+static int eeprom_attach_adapter(struct i2c_adapter *adapter);
+static int eeprom_detect(struct i2c_adapter *adapter, int address, int kind);
+static int eeprom_detach_client(struct i2c_client *client);
+
+/* This is the driver that will be inserted */
+static struct i2c_driver eeprom_driver = {
+	.owner		= THIS_MODULE,
+	.name		= "eeprom",
+	.id		= I2C_DRIVERID_EEPROM,
+	.flags		= I2C_DF_NOTIFY,
+	.attach_adapter	= eeprom_attach_adapter,
+	.detach_client	= eeprom_detach_client,
+};
+
+static int eeprom_id = 0;
+
+static void eeprom_update_client(struct i2c_client *client)
+{
+	struct eeprom_data *data = i2c_get_clientdata(client);
+	int i, j;
+
+	down(&data->update_lock);
+
+	if ((jiffies - data->last_updated > 300 * HZ) |
+	    (jiffies < data->last_updated) || !data->valid) {
+		dev_dbg(&client->dev, "Starting eeprom update\n");
+
+		if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK)) {
+			for (i=0; i < EEPROM_SIZE; i += I2C_SMBUS_I2C_BLOCK_MAX)
+				if (i2c_smbus_read_i2c_block_data(client, i, data->data + i) != I2C_SMBUS_I2C_BLOCK_MAX)
+					goto exit;
+		} else {
+			if (i2c_smbus_write_byte(client, 0)) {
+				dev_dbg(&client->dev, "eeprom read start has failed!\n");
+				goto exit;
+			}
+			for (i = 0; i < EEPROM_SIZE; i++) {
+				j = i2c_smbus_read_byte(client);
+				if (j < 0)
+					goto exit;
+				data->data[i] = (u8) j;
+			}
+		}
+		data->last_updated = jiffies;
+		data->valid = 1;
+	}
+exit:
+	up(&data->update_lock);
+}
+
+static ssize_t eeprom_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
+{
+	struct i2c_client *client = to_i2c_client(container_of(kobj, struct device, kobj));
+	struct eeprom_data *data = i2c_get_clientdata(client);
+
+	eeprom_update_client(client);
+
+	if (off > EEPROM_SIZE)
+		return 0;
+	if (off + count > EEPROM_SIZE)
+		count = EEPROM_SIZE - off;
+
+	memcpy(buf, &data->data[off], count);
+	return count;
+}
+
+static struct bin_attribute eeprom_attr = {
+	.attr = {
+		.name = "eeprom",
+		.mode = S_IRUGO,
+	},
+	.size = EEPROM_SIZE,
+	.read = eeprom_read,
+};
+
+static int eeprom_attach_adapter(struct i2c_adapter *adapter)
+{
+	return i2c_detect(adapter, &addr_data, eeprom_detect);
+}
+
+/* This function is called by i2c_detect */
+int eeprom_detect(struct i2c_adapter *adapter, int address, int kind)
+{
+	int i, cs;
+	struct i2c_client *new_client;
+	struct eeprom_data *data;
+	enum eeprom_nature nature = UNKNOWN;
+	int err = 0;
+
+	/* Make sure we aren't probing the ISA bus!! This is just a safety check
+	   at this moment; i2c_detect really won't call us. */
+#ifdef DEBUG
+	if (i2c_is_isa_adapter(adapter)) {
+		dev_dbg(&adapter->dev, " eeprom_detect called for an ISA bus adapter?!?\n");
+		return 0;
+	}
+#endif
+
+	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+		goto exit;
+
+	/* OK. For now, we presume we have a valid client. We now create the
+	   client structure, even though we cannot fill it completely yet.
+	   But it allows us to access eeprom_{read,write}_value. */
+	if (!(new_client = kmalloc(sizeof(struct i2c_client) +
+				   sizeof(struct eeprom_data),
+				   GFP_KERNEL))) {
+		err = -ENOMEM;
+		goto exit;
+	}
+	memset(new_client, 0x00, sizeof(struct i2c_client) +
+				 sizeof(struct eeprom_data));
+
+	data = (struct eeprom_data *) (new_client + 1);
+	memset(data, 0xff, EEPROM_SIZE);
+	i2c_set_clientdata(new_client, data);
+	new_client->addr = address;
+	new_client->adapter = adapter;
+	new_client->driver = &eeprom_driver;
+	new_client->flags = 0;
+
+	/* Now, we do the remaining detection. It is not there, unless you force
+	   the checksum to work out. */
+	if (checksum) {
+		/* prevent 24RF08 corruption */
+		i2c_smbus_write_quick(new_client, 0);
+		cs = 0;
+		for (i = 0; i <= 0x3e; i++)
+			cs += i2c_smbus_read_byte_data(new_client, i);
+		cs &= 0xff;
+		if (i2c_smbus_read_byte_data (new_client, EEPROM_REG_CHECKSUM) != cs)
+			goto exit_kfree;
+	}
+
+	/* Detect the Vaio nature of EEPROMs.
+	   We use the "PCG-" prefix as the signature. */
+	if (address == 0x57) {
+		if (i2c_smbus_read_byte_data(new_client, 0x80) == 'P' && 
+		    i2c_smbus_read_byte_data(new_client, 0x81) == 'C' && 
+		    i2c_smbus_read_byte_data(new_client, 0x82) == 'G' &&
+		    i2c_smbus_read_byte_data(new_client, 0x83) == '-')
+			nature = VAIO;
+	}
+
+	/* If this is a VIAO, then we only allow root to read from this file,
+	   as BIOS passwords can be present here in plaintext */
+	switch (nature) {
+ 	case VAIO:
+		eeprom_attr.attr.mode = S_IRUSR;
+		break;
+	default:
+		eeprom_attr.attr.mode = S_IRUGO;
+	}
+
+	/* Fill in the remaining client fields */
+	strncpy(new_client->name, "eeprom", I2C_NAME_SIZE);
+	new_client->id = eeprom_id++;
+	data->valid = 0;
+	init_MUTEX(&data->update_lock);
+
+	/* Tell the I2C layer a new client has arrived */
+	if ((err = i2c_attach_client(new_client)))
+		goto exit_kfree;
+
+	/* create the sysfs eeprom file */
+	sysfs_create_bin_file(&new_client->dev.kobj, &eeprom_attr);
+
+	return 0;
+
+exit_kfree:
+	kfree(new_client);
+exit:
+	return err;
+}
+
+static int eeprom_detach_client(struct i2c_client *client)
+{
+	int err;
+
+	err = i2c_detach_client(client);
+	if (err) {
+		dev_err(&client->dev, "Client deregistration failed, client not detached.\n");
+		return err;
+	}
+
+	kfree(client);
+
+	return 0;
+}
+
+static int __init eeprom_init(void)
+{
+	return i2c_add_driver(&eeprom_driver);
+}
+
+static void __exit eeprom_exit(void)
+{
+	i2c_del_driver(&eeprom_driver);
+}
+
+
+MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
+		"Philip Edelbrock <phil@netroedge.com> and "
+		"Greg Kroah-Hartman <greg@kroah.com>");
+MODULE_DESCRIPTION("I2C EEPROM driver");
+MODULE_LICENSE("GPL");
+
+module_init(eeprom_init);
+module_exit(eeprom_exit);

drivers/i2c/i2c-sensor.c

@@ -50,10 +50,7 @@ int i2c_detect(struct i2c_adapter *adapter,
 		return -1;
 
 	for (addr = 0x00; addr <= (is_isa ? 0xffff : 0x7f); addr++) {
-		void *region_used = request_region(addr, 1, "foo");
-		release_region(addr, 1);
-		if ((is_isa && (region_used == NULL)) ||
-		    (!is_isa && i2c_check_addr(adapter, addr)))
+		if (!is_isa && i2c_check_addr(adapter, addr))
 			continue;
 
 		/* If it is in one of the force entries, we don't do any

drivers/usb/Makefile

@@ -35,7 +35,6 @@ obj-$(CONFIG_USB_SE401)		+= media/
 obj-$(CONFIG_USB_STV680)	+= media/
 obj-$(CONFIG_USB_VICAM)		+= media/
 
-obj-$(CONFIG_USB_AX8817X)	+= net/
 obj-$(CONFIG_USB_CATC)		+= net/
 obj-$(CONFIG_USB_KAWETH)	+= net/
 obj-$(CONFIG_USB_PEGASUS)	+= net/

drivers/usb/Makefile.lib

-obj-$(CONFIG_USB_AX8817X)	+= crc32.o
 obj-$(CONFIG_USB_CATC)		+= crc32.o
 obj-$(CONFIG_USB_SPEEDTOUCH)	+= crc32.o
 obj-$(CONFIG_USB_USBNET)	+= crc32.o

drivers/usb/class/usb-midi.c

@@ -1750,7 +1750,7 @@ static int alloc_usb_midi_device( struct usb_device *d, struct usb_midi_state *s
 	return 0;
 
  error_end:
-	if ( mdevs != NULL && devices > 0 ) {
+	if ( mdevs != NULL ) {
 		for ( i=0 ; i<devices ; i++ ) {
 			if ( mdevs[i] != NULL ) {
 				unregister_sound_midi( mdevs[i]->dev_midi );

drivers/usb/core/config.c

@@ -237,9 +237,6 @@ int usb_parse_configuration(struct usb_host_config *config, char *buffer, int si
 		memset(interface, 0, sizeof(struct usb_interface));
 		interface->dev.release = usb_release_intf;
 		device_initialize(&interface->dev);
-
-		/* put happens in usb_destroy_configuration */
-		get_device(&interface->dev);
 	}
 
 	/* Go through the descriptors, checking their length and counting the

drivers/usb/core/driverfs.c

@@ -23,22 +23,44 @@
 #include "usb.h"
 
 /* Active configuration fields */
-#define usb_actconfig_attr(field, format_string)			\
+#define usb_actconfig_show(field, format_string)			\
 static ssize_t								\
 show_##field (struct device *dev, char *buf)				\
 {									\
 	struct usb_device *udev;					\
 									\
 	udev = to_usb_device (dev);					\
+	if (udev->actconfig) \
 	return sprintf (buf, format_string, udev->actconfig->desc.field); \
+	else return 0;							\
 }									\
+
+#define usb_actconfig_attr(field, format_string)			\
+usb_actconfig_show(field,format_string)					\
 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
 
 usb_actconfig_attr (bNumInterfaces, "%2d\n")
-usb_actconfig_attr (bConfigurationValue, "%2d\n")
 usb_actconfig_attr (bmAttributes, "%2x\n")
 usb_actconfig_attr (bMaxPower, "%3dmA\n")
 
+/* configuration value is always present, and r/w */
+usb_actconfig_show(bConfigurationValue,"%u\n");
+
+static ssize_t
+set_bConfigurationValue (struct device *dev, const char *buf, size_t count)
+{
+	struct usb_device	*udev = udev = to_usb_device (dev);
+	int			config, value;
+
+	if (sscanf (buf, "%u", &config) != 1 || config > 255)
+		return -EINVAL;
+	value = usb_set_configuration (udev, config);
+	return (value < 0) ? value : count;
+}
+
+static DEVICE_ATTR(bConfigurationValue, S_IRUGO | S_IWUSR, 
+		show_bConfigurationValue, set_bConfigurationValue);
+
 /* String fields */
 static ssize_t show_product (struct device *dev, char *buf)
 {

drivers/usb/core/hcd-pci.c

@@ -273,17 +273,17 @@ int usb_hcd_pci_suspend (struct pci_dev *dev, u32 state)
 	int			retval = 0;
 
 	hcd = pci_get_drvdata(dev);
+	dev_dbg (hcd->controller, "suspend D%d --> D%d\n",
+			dev->current_state, state);
+
 	switch (hcd->state) {
 	case USB_STATE_HALT:
 		dev_dbg (hcd->controller, "halted; hcd not suspended\n");
 		break;
 	case USB_STATE_SUSPENDED:
-		dev_dbg (hcd->controller, "suspend D%d --> D%d\n",
-				dev->current_state, state);
+		dev_dbg (hcd->controller, "hcd already suspended\n");
 		break;
 	default:
-		dev_dbg (hcd->controller, "suspend to state %d\n", state);
-
 		/* remote wakeup needs hub->suspend() cooperation */
 		// pci_enable_wake (dev, 3, 1);
 
@@ -292,6 +292,9 @@ int usb_hcd_pci_suspend (struct pci_dev *dev, u32 state)
 		/* driver may want to disable DMA etc */
 		hcd->state = USB_STATE_QUIESCING;
 		retval = hcd->driver->suspend (hcd, state);
+		if (retval)
+			dev_dbg (hcd->controller, "suspend fail, retval %d\n",
+					retval);
 	}
 
  	pci_set_power_state (dev, state);
@@ -311,6 +314,9 @@ int usb_hcd_pci_resume (struct pci_dev *dev)
 	int			retval;
 
 	hcd = pci_get_drvdata(dev);
+	dev_dbg (hcd->controller, "resume from state D%d\n",
+			dev->current_state);
+
 	if (hcd->state != USB_STATE_SUSPENDED) {
 		dev_dbg (hcd->controller, "can't resume, not suspended!\n");
 		return -EL3HLT;

drivers/usb/core/message.c

@@ -781,18 +781,40 @@ void usb_disable_interface(struct usb_device *dev, struct usb_interface *intf)
  * @skip_ep0: 0 to disable endpoint 0, 1 to skip it.
  *
  * Disables all the device's endpoints, potentially including endpoint 0.
- * Deallocates hcd/hardware state for the endpoints ... and nukes all
- * pending urbs.
+ * Deallocates hcd/hardware state for the endpoints (nuking all or most
+ * pending urbs) and usbcore state for the interfaces, so that usbcore
+ * must usb_set_configuration() before any interfaces could be used.
  */
 void usb_disable_device(struct usb_device *dev, int skip_ep0)
 {
 	int i;
 
-	dbg("nuking URBs for device %s", dev->dev.bus_id);
+	dev_dbg(&dev->dev, "%s nuking %s URBs\n", __FUNCTION__,
+			skip_ep0 ? "non-ep0" : "all");
 	for (i = skip_ep0; i < 16; ++i) {
 		usb_disable_endpoint(dev, i);
 		usb_disable_endpoint(dev, i + USB_DIR_IN);
 	}
+	dev->toggle[0] = dev->toggle[1] = 0;
+	dev->halted[0] = dev->halted[1] = 0;
+
+	/* getting rid of interfaces will disconnect
+	 * any drivers bound to them (a key side effect)
+	 */
+	if (dev->actconfig) {
+		for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
+			struct usb_interface	*interface;
+
+			/* remove this interface */
+			interface = dev->actconfig->interface[i];
+			dev_dbg (&dev->dev, "unregistering interface %s\n",
+				interface->dev.bus_id);
+			device_del(&interface->dev);
+		}
+		dev->actconfig = 0;
+		if (dev->state == USB_STATE_CONFIGURED)
+			dev->state = USB_STATE_ADDRESS;
+	}
 }
 
 
@@ -979,6 +1001,9 @@ int usb_reset_configuration(struct usb_device *dev)
 	int			i, retval;
 	struct usb_host_config	*config;
 
+	/* dev->serialize guards all config changes */
+	down(&dev->serialize);
+
 	for (i = 1; i < 16; ++i) {
 		usb_disable_endpoint(dev, i);
 		usb_disable_endpoint(dev, i + USB_DIR_IN);
@@ -989,8 +1014,10 @@ int usb_reset_configuration(struct usb_device *dev)
 			USB_REQ_SET_CONFIGURATION, 0,
 			config->desc.bConfigurationValue, 0,
 			NULL, 0, HZ * USB_CTRL_SET_TIMEOUT);
-	if (retval < 0)
-		return retval;
+	if (retval < 0) {
+		dev->state = USB_STATE_ADDRESS;
+		goto done;
+	}
 
 	dev->toggle[0] = dev->toggle[1] = 0;
 	dev->halted[0] = dev->halted[1] = 0;
@@ -1002,7 +1029,9 @@ int usb_reset_configuration(struct usb_device *dev)
 		intf->act_altsetting = 0;
 		usb_enable_interface(dev, intf);
 	}
-	return 0;
+done:
+	up(&dev->serialize);
+	return (retval < 0) ? retval : 0;
 }
 
 /**
@@ -1012,72 +1041,105 @@ int usb_reset_configuration(struct usb_device *dev)
  * Context: !in_interrupt ()
  *
  * This is used to enable non-default device modes.  Not all devices
- * support this kind of configurability.  By default, configuration
- * zero is selected after enumeration; many devices only have a single
+ * use this kind of configurability; many devices only have one
  * configuration.
  *
- * USB devices may support one or more configurations, which affect
+ * USB device configurations may affect Linux interoperability,
  * power consumption and the functionality available.  For example,
  * the default configuration is limited to using 100mA of bus power,
  * so that when certain device functionality requires more power,
- * and the device is bus powered, that functionality will be in some
+ * and the device is bus powered, that functionality should be in some
  * non-default device configuration.  Other device modes may also be
  * reflected as configuration options, such as whether two ISDN
- * channels are presented as independent 64Kb/s interfaces or as one
- * bonded 128Kb/s interface.
+ * channels are available independently; and choosing between open
+ * standard device protocols (like CDC) or proprietary ones.
  *
  * Note that USB has an additional level of device configurability,
  * associated with interfaces.  That configurability is accessed using
  * usb_set_interface().
  *
- * This call is synchronous, and may not be used in an interrupt context.
+ * This call is synchronous. The calling context must be able to sleep,
+ * and must not hold the driver model lock for USB; usb device driver
+ * probe() methods may not use this routine.
  *
  * Returns zero on success, or else the status code returned by the
- * underlying usb_control_msg() call.
+ * underlying call that failed.  On succesful completion, each interface
+ * in the original device configuration has been destroyed, and each one
+ * in the new configuration has been probed by all relevant usb device
+ * drivers currently known to the kernel.
  */
 int usb_set_configuration(struct usb_device *dev, int configuration)
 {
 	int i, ret;
 	struct usb_host_config *cp = NULL;
 	
+	/* dev->serialize guards all config changes */
+	down(&dev->serialize);
+
 	for (i=0; i<dev->descriptor.bNumConfigurations; i++) {
 		if (dev->config[i].desc.bConfigurationValue == configuration) {
 			cp = &dev->config[i];
 			break;
 		}
 	}
-	if ((!cp && configuration != 0) || (cp && configuration == 0)) {
-		warn("selecting invalid configuration %d", configuration);
-		return -EINVAL;
+	if ((!cp && configuration != 0)) {
+		ret = -EINVAL;
+		goto out;
 	}
+	if (cp && configuration == 0)
+		dev_warn(&dev->dev, "config 0 descriptor??\n");
 
-	/* if it's already configured, clear out old state first. */
+	/* if it's already configured, clear out old state first.
+	 * getting rid of old interfaces means unbinding their drivers.
+	 */
 	if (dev->state != USB_STATE_ADDRESS)
 		usb_disable_device (dev, 1);	// Skip ep0
-	dev->toggle[0] = dev->toggle[1] = 0;
-	dev->halted[0] = dev->halted[1] = 0;
-	dev->state = USB_STATE_ADDRESS;
 
 	if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 			USB_REQ_SET_CONFIGURATION, 0, configuration, 0,
 			NULL, 0, HZ * USB_CTRL_SET_TIMEOUT)) < 0)
-		return ret;
-	if (configuration)
-		dev->state = USB_STATE_CONFIGURED;
+		goto out;
+
 	dev->actconfig = cp;
+	if (!configuration)
+		dev->state = USB_STATE_ADDRESS;
+	else {
+		dev->state = USB_STATE_CONFIGURED;
 
-	/* reset more hc/hcd interface/endpoint state */
+		/* re-initialize hc/hcd/usbcore interface/endpoint state.
+		 * this triggers binding of drivers to interfaces; and
+		 * maybe probe() calls will choose different altsettings.
+		 */
 		for (i = 0; i < cp->desc.bNumInterfaces; ++i) {
 			struct usb_interface *intf = cp->interface[i];
+			struct usb_interface_descriptor *desc;
 
 			intf->act_altsetting = 0;
+			desc = &intf->altsetting [0].desc;
 			usb_enable_interface(dev, intf);
+
+			intf->dev.parent = &dev->dev;
+			intf->dev.driver = NULL;
+			intf->dev.bus = &usb_bus_type;
+			intf->dev.dma_mask = dev->dev.dma_mask;
+			sprintf (&intf->dev.bus_id[0], "%d-%s:%d.%d",
+				 dev->bus->busnum, dev->devpath,
+				 configuration,
+				 desc->bInterfaceNumber);
+			dev_dbg (&dev->dev,
+				"registering %s (config #%d, interface %d)\n",
+				intf->dev.bus_id, configuration,
+				desc->bInterfaceNumber);
+			device_add (&intf->dev);
+			usb_create_driverfs_intf_files (intf);
+		}
 	}
 
-	return 0;
+out:
+	up(&dev->serialize);
+	return ret;
 }
 
-
 /**
  * usb_string - returns ISO 8859-1 version of a string descriptor
  * @dev: the device whose string descriptor is being retrieved

drivers/usb/core/usb.c

@@ -898,6 +898,7 @@ void usb_disconnect(struct usb_device **pdev)
 	 * this device will fail.
 	 */
 	dev->state = USB_STATE_NOTATTACHED;
+	down(&dev->serialize);
 
 	dev_info (&dev->dev, "USB disconnect, address %d\n", dev->devnum);
 
@@ -908,32 +909,19 @@ void usb_disconnect(struct usb_device **pdev)
 			usb_disconnect(child);
 	}
 
-	/* deallocate hcd/hardware state ... and nuke all pending urbs */
+	/* deallocate hcd/hardware state ... nuking all pending urbs and
+	 * cleaning up all state associated with the current configuration
+	 */
 	usb_disable_device(dev, 0);
 
-	/* disconnect() drivers from interfaces (a key side effect) */
-	dev_dbg (&dev->dev, "unregistering interfaces\n");
-	if (dev->actconfig) {
-		for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
-			struct usb_interface	*interface;
-
-			/* remove this interface */
-			interface = dev->actconfig->interface[i];
-			device_unregister(&interface->dev);
-		}
-	}
-
 	dev_dbg (&dev->dev, "unregistering device\n");
 	/* Free the device number and remove the /proc/bus/usb entry */
 	if (dev->devnum > 0) {
 		clear_bit(dev->devnum, dev->bus->devmap.devicemap);
 		usbfs_remove_device(dev);
 	}
+	up(&dev->serialize);
 	device_unregister(&dev->dev);
-
-	/* Decrement the reference count, it'll auto free everything when */
-	/* it hits 0 which could very well be now */
-	usb_put_dev(dev);
 }
 
 /**
@@ -1017,7 +1005,6 @@ int usb_new_device(struct usb_device *dev, struct device *parent)
 	dev->dev.driver = &usb_generic_driver;
 	dev->dev.bus = &usb_bus_type;
 	dev->dev.driver_data = &usb_generic_driver_data;
-	usb_get_dev(dev);
 	if (dev->dev.bus_id[0] == 0)
 		sprintf (&dev->dev.bus_id[0], "%d-%s",
 			 dev->bus->busnum, dev->devpath);
@@ -1090,27 +1077,12 @@ int usb_new_device(struct usb_device *dev, struct device *parent)
 
 	err = usb_get_configuration(dev);
 	if (err < 0) {
-		dev_err(&dev->dev, "unable to get device %d configuration (error=%d)\n",
-			dev->devnum, err);
+		dev_err(&dev->dev, "can't read configurations, error %d\n",
+			err);
 		goto fail;
 	}
 
-	/* choose and set the configuration here */
-	if (dev->descriptor.bNumConfigurations != 1) {
-		dev_info(&dev->dev,
-			"configuration #%d chosen from %d choices\n",
-			dev->config[0].desc.bConfigurationValue,
-			dev->descriptor.bNumConfigurations);
-	}
-	err = usb_set_configuration(dev, dev->config[0].desc.bConfigurationValue);
-	if (err) {
-		dev_err(&dev->dev, "failed to set device %d default configuration (error=%d)\n",
-			dev->devnum, err);
-		goto fail;
-	}
-
-	/* USB device state == configured ... tell the world! */
-
+	/* Tell the world! */
 	dev_dbg(&dev->dev, "new device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
 		dev->descriptor.iManufacturer, dev->descriptor.iProduct, dev->descriptor.iSerialNumber);
 
@@ -1123,30 +1095,32 @@ int usb_new_device(struct usb_device *dev, struct device *parent)
 		usb_show_string(dev, "SerialNumber", dev->descriptor.iSerialNumber);
 #endif
 
-	/* put into sysfs, with device and config specific files */
+	/* put device-specific files into sysfs */
 	err = device_add (&dev->dev);
-	if (err)
+	if (err) {
+		dev_err(&dev->dev, "can't device_add, error %d\n", err);
 		goto fail;
+	}
 	usb_create_driverfs_dev_files (dev);
 
-	/* Register all of the interfaces for this device with the driver core.
-	 * Remember, interfaces get bound to drivers, not devices. */
-	for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
-		struct usb_interface *interface = dev->actconfig->interface[i];
-		struct usb_interface_descriptor *desc;
-
-		desc = &interface->altsetting [interface->act_altsetting].desc;
-		interface->dev.parent = &dev->dev;
-		interface->dev.driver = NULL;
-		interface->dev.bus = &usb_bus_type;
-		interface->dev.dma_mask = parent->dma_mask;
-		sprintf (&interface->dev.bus_id[0], "%d-%s:%d",
-			 dev->bus->busnum, dev->devpath,
-			 desc->bInterfaceNumber);
-		dev_dbg (&dev->dev, "%s - registering interface %s\n", __FUNCTION__, interface->dev.bus_id);
-		device_add (&interface->dev);
-		usb_create_driverfs_intf_files (interface);
+	/* choose and set the configuration. that registers the interfaces
+	 * with the driver core, and lets usb device drivers bind to them.
+	 */
+	if (dev->descriptor.bNumConfigurations != 1) {
+		dev_info(&dev->dev,
+			"configuration #%d chosen from %d choices\n",
+			dev->config[0].desc.bConfigurationValue,
+			dev->descriptor.bNumConfigurations);
 	}
+	err = usb_set_configuration(dev,
+			dev->config[0].desc.bConfigurationValue);
+	if (err) {
+		dev_err(&dev->dev, "can't set config #%d, error %d\n",
+			dev->config[0].desc.bConfigurationValue, err);
+		goto fail;
+	}
+
+	/* USB device state == configured ... usable */
 
 	/* add a /proc/bus/usb entry */
 	usbfs_add_device(dev);
@@ -1156,7 +1130,6 @@ int usb_new_device(struct usb_device *dev, struct device *parent)
 	dev->state = USB_STATE_DEFAULT;
 	clear_bit(dev->devnum, dev->bus->devmap.devicemap);
 	dev->devnum = -1;
-	usb_put_dev(dev);
 	return err;
 }
 

drivers/usb/gadget/inode.c

@@ -354,6 +354,7 @@ static ssize_t
 ep_io (struct ep_data *epdata, void *buf, unsigned len)
 {
 	DECLARE_COMPLETION (done);
+	int value;
 
 	spin_lock_irq (&epdata->dev->lock);
 	if (likely (epdata->ep != NULL)) {
@@ -363,14 +364,12 @@ ep_io (struct ep_data *epdata, void *buf, unsigned len)
 		req->complete = epio_complete;
 		req->buf = buf;
 		req->length = len;
-		epdata->status = usb_ep_queue (epdata->ep, req, GFP_ATOMIC);
+		value = usb_ep_queue (epdata->ep, req, GFP_ATOMIC);
 	} else
-		epdata->status = -ENODEV;
+		value = -ENODEV;
 	spin_unlock_irq (&epdata->dev->lock);
 
-	if (epdata->status == 0) {
-		int	value;
-
+	if (likely (value == 0)) {
 		value = wait_event_interruptible (done.wait, done.done);
 		if (value != 0) {
 			spin_lock_irq (&epdata->dev->lock);
@@ -378,17 +377,21 @@ ep_io (struct ep_data *epdata, void *buf, unsigned len)
 				DBG (epdata->dev, "%s i/o interrupted\n",
 						epdata->name);
 				usb_ep_dequeue (epdata->ep, epdata->req);
+				spin_unlock_irq (&epdata->dev->lock);
+
 				wait_event (done.wait, done.done);
-				if (epdata->status == 0)
-					epdata->status = value;
+				if (epdata->status == -ECONNRESET)
+					epdata->status = -EINTR;
 			} else {
+				spin_unlock_irq (&epdata->dev->lock);
+
 				DBG (epdata->dev, "endpoint gone\n");
 				epdata->status = -ENODEV;
 			}
-			spin_unlock_irq (&epdata->dev->lock);
-		}
 		}
 		return epdata->status;
+	}
+	return value;
 }
 
 
@@ -424,10 +427,12 @@ ep_read (struct file *fd, char *buf, size_t len, loff_t *ptr)
 	if (unlikely (!kbuf))
 		goto free1;
 
-	VDEBUG (data->dev, "%s read %d OUT\n", data->name, len);
 	value = ep_io (data, kbuf, len);
+	VDEBUG (data->dev, "%s read %d OUT, status %d\n",
+		data->name, len, value);
 	if (value >= 0 && copy_to_user (buf, kbuf, value))
 		value = -EFAULT;
+
 free1:
 	up (&data->lock);
 	kfree (kbuf);
@@ -470,8 +475,9 @@ ep_write (struct file *fd, const char *buf, size_t len, loff_t *ptr)
 		goto free1;
 	}
 
-	VDEBUG (data->dev, "%s write %d IN\n", data->name, len);
 	value = ep_io (data, kbuf, len);
+	VDEBUG (data->dev, "%s write %d IN, status %d\n",
+		data->name, len, value);
 free1:
 	up (&data->lock);
 	kfree (kbuf);
@@ -1200,9 +1206,11 @@ gadgetfs_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
 			if (value >= 0)
 				value = min (ctrl->wLength, (u16) value);
 			break;
-
-		default:
+		case USB_DT_STRING:
 			goto unrecognized;
+
+		default:		// all others are errors
+			break;
 		}
 		break;
 

drivers/usb/host/uhci-hcd.c

@@ -1965,13 +1965,11 @@ static void reset_hc(struct uhci_hcd *uhci)
 	outw(USBCMD_GRESET, io_addr + USBCMD);
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	schedule_timeout((HZ*50+999) / 1000);
-	set_current_state(TASK_RUNNING);
 	outw(0, io_addr + USBCMD);
 
 	/* Another 10ms delay */
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	schedule_timeout((HZ*10+999) / 1000);
-	set_current_state(TASK_RUNNING);
 	uhci->resume_detect = 0;
 }
 

drivers/usb/image/scanner.c

 /* -*- linux-c -*- */
 
 /* 
- * Driver for USB Scanners (linux-2.5)
+ * Driver for USB Scanners (linux-2.6)
  *
  * Copyright (C) 1999, 2000, 2001, 2002 David E. Nelson
  * Copyright (C) 2002, 2003 Henning Meier-Geinitz
@@ -369,6 +369,18 @@
  *    - Added vendor/product ids for Avision, Canon, HP, Microtek and Relisys scanners.
  *    - Clean up irq urb when not enough memory is available.
  *
+ * 0.4.15  2003-09-22
+ *    - Use static declarations for usb_scanner_init/usb_scanner_exit 
+ *      (Daniele Bellucci).
+ *    - Report back return codes of usb_register and usb_usbmit_urb instead of -1 or
+ *      -ENONMEM (Daniele Bellucci).
+ *    - Balancing usb_register_dev/usb_deregister_dev in probe_scanner when a fail 
+ *      condition occours (Daniele Bellucci).
+ *    - Added vendor/product ids for Canon, HP, Microtek, Mustek, Siemens, UMAX, and
+ *      Visioneer scanners.
+ *    - Added test for USB_CLASS_CDC_DATA which is used by some fingerprint scanners.
+ *
+ *
  * TODO
  *    - Performance
  *    - Select/poll methods
@@ -950,6 +962,7 @@ probe_scanner(struct usb_interface *intf,
  
 	if (interface[0].desc.bInterfaceClass != USB_CLASS_VENDOR_SPEC &&
 	    interface[0].desc.bInterfaceClass != USB_CLASS_PER_INTERFACE &&
+	    interface[0].desc.bInterfaceClass != USB_CLASS_CDC_DATA &&
 	    interface[0].desc.bInterfaceClass != SCN_CLASS_SCANJET) {
 		dbg("probe_scanner: This interface doesn't look like a scanner (class=0x%x).", interface[0].desc.bInterfaceClass);
 		return -ENODEV;
@@ -1043,6 +1056,7 @@ probe_scanner(struct usb_interface *intf,
 
 	scn->scn_irq = usb_alloc_urb(0, GFP_KERNEL);
 	if (!scn->scn_irq) {
+		usb_deregister_dev(intf, &scanner_class);
 		kfree(scn);
 		up(&scn_mutex);
 		return -ENOMEM;
@@ -1061,11 +1075,13 @@ probe_scanner(struct usb_interface *intf,
 			     // endpoint[(int)have_intr].bInterval);
 			     250);
 
-	        if (usb_submit_urb(scn->scn_irq, GFP_KERNEL)) {
+		retval = usb_submit_urb(scn->scn_irq, GFP_KERNEL);
+		if (retval) {
 			err("probe_scanner(%d): Unable to allocate INT URB.", intf->minor);
+			usb_deregister_dev(intf, &scanner_class);
                 	kfree(scn);
 			up(&scn_mutex);
-                	return -ENOMEM;
+                	return retval;
         	}
 	}
 
@@ -1076,6 +1092,7 @@ probe_scanner(struct usb_interface *intf,
 		if (have_intr)
 			usb_unlink_urb(scn->scn_irq);
 		usb_free_urb(scn->scn_irq);
+		usb_deregister_dev(intf, &scanner_class);
 		kfree(scn);
 		up(&scn_mutex);
 		return -ENOMEM;
@@ -1087,6 +1104,7 @@ probe_scanner(struct usb_interface *intf,
 		if (have_intr)
 			usb_unlink_urb(scn->scn_irq);
 		usb_free_urb(scn->scn_irq);
+		usb_deregister_dev(intf, &scanner_class);
 		kfree(scn->obuf);
 		kfree(scn);
 		up(&scn_mutex);
@@ -1169,22 +1187,25 @@ usb_driver scanner_driver = {
 	.id_table =	ids,
 };
 
-void __exit
+static void __exit
 usb_scanner_exit(void)
 {
 	usb_deregister(&scanner_driver);
 }
 
-int __init
+static int __init
 usb_scanner_init (void)
 {
-        if (usb_register(&scanner_driver) < 0)
-                return -1;
+	int retval;
+	retval = usb_register(&scanner_driver);
+	if (retval)
+		goto out;
 
 	info(DRIVER_VERSION ":" DRIVER_DESC);
 	if (vendor != -1 && product != -1)
 		info("probe_scanner: User specified USB scanner -- Vendor:Product - %x:%x", vendor, product);
-	return 0;
+ out:
+	return retval;
 }
 
 module_init(usb_scanner_init);

drivers/usb/image/scanner.h

 /*
- * Driver for USB Scanners (linux-2.5)
+ * Driver for USB Scanners (linux-2.6)
  *
  * Copyright (C) 1999, 2000, 2001, 2002 David E. Nelson
  * Previously maintained by Brian Beattie
@@ -43,7 +43,7 @@
 
 // #define DEBUG
 
-#define DRIVER_VERSION "0.4.14"
+#define DRIVER_VERSION "0.4.15"
 #define DRIVER_DESC "USB Scanner Driver"
 
 #include <linux/usb.h>
@@ -122,7 +122,10 @@ static struct usb_device_id scanner_device_ids [] = {
 	{ USB_DEVICE(0x04a9, 0x220d) }, /* CanoScan N670U/N676U/LIDE 20 */
 	{ USB_DEVICE(0x04a9, 0x220e) }, /* CanoScan N1240U/LIDE 30 */
 	{ USB_DEVICE(0x04a9, 0x220f) },	/* CanoScan 8000F */
+	{ USB_DEVICE(0x04a9, 0x2210) },	/* CanoScan 9900F */
+	{ USB_DEVICE(0x04a9, 0x2212) },	/* CanoScan 5000F */
 	{ USB_DEVICE(0x04a9, 0x2213) },	/* LIDE 50 */
+	{ USB_DEVICE(0x04a9, 0x2215) },	/* CanoScan 3000 */
 	{ USB_DEVICE(0x04a9, 0x3042) }, /* FS4000US */
 	/* Colorado -- See Primax/Colorado below */
 	/* Compaq */
@@ -158,7 +161,9 @@ static struct usb_device_id scanner_device_ids [] = {
 	//	{ USB_DEVICE(0x03f0, 0x0701) },	/* ScanJet 5300C - NOT SUPPORTED - use hpusbscsi driver */
 	{ USB_DEVICE(0x03f0, 0x0705) }, /* ScanJet 4400C */
 	//	{ USB_DEVICE(0x03f0, 0x0801) },	/* ScanJet 7400C - NOT SUPPORTED - use hpusbscsi driver */
+	{ USB_DEVICE(0x03f0, 0x0805) },	/* ScanJet 4470c */
 	{ USB_DEVICE(0x03f0, 0x0901) }, /* ScanJet 2300C */
+	{ USB_DEVICE(0x03f0, 0x0a01) },	/* ScanJet 2400c */
 	{ USB_DEVICE(0x03F0, 0x1005) },	/* ScanJet 5400C */
 	{ USB_DEVICE(0x03F0, 0x1105) },	/* ScanJet 5470C */
 	{ USB_DEVICE(0x03f0, 0x1205) }, /* ScanJet 5550C */
@@ -177,9 +182,11 @@ static struct usb_device_id scanner_device_ids [] = {
 	/* Memorex */
 	{ USB_DEVICE(0x0461, 0x0346) }, /* 6136u - repackaged Primax ? */
 	/* Microtek */
+	{ USB_DEVICE(0x05da, 0x20a7) },	/* ScanMaker 5600 */
 	{ USB_DEVICE(0x05da, 0x20c9) }, /* ScanMaker 6700 */
 	{ USB_DEVICE(0x05da, 0x30ce) },	/* ScanMaker 3800 */
 	{ USB_DEVICE(0x05da, 0x30cf) },	/* ScanMaker 4800 */
+	{ USB_DEVICE(0x05da, 0x30d4) },	/* ScanMaker 3830 + 3840 */
 	{ USB_DEVICE(0x04a7, 0x0224) },	/* Scanport 3000 (actually Visioneer?)*/
 	/* The following SCSI-over-USB Microtek devices are supported by the
 	   microtek driver: Enable SCSI and USB Microtek in kernel config */
@@ -214,6 +221,7 @@ static struct usb_device_id scanner_device_ids [] = {
 	{ USB_DEVICE(0x055f, 0x021e) }, /* BearPaw 1200 TA/CS */
 	{ USB_DEVICE(0x055f, 0x0400) }, /* BearPaw 2400 TA PRO */
 	{ USB_DEVICE(0x055f, 0x0401) },	/* P 3600 A3 Pro */
+	{ USB_DEVICE(0x055f, 0x0409) },	/* BearPaw 2448TA Pro */
 	{ USB_DEVICE(0x055f, 0x0873) }, /* ScanExpress 600 USB */
 	{ USB_DEVICE(0x055f, 0x1000) }, /* BearPaw 4800 TA PRO */
 	//	{ USB_DEVICE(0x05d8, 0x4002) }, /* BearPaw 1200 CU and ScanExpress 1200 UB Plus (see Artec) */
@@ -279,6 +287,9 @@ static struct usb_device_id scanner_device_ids [] = {
 	{ USB_DEVICE(0x04b8, 0x011e) }, /* Perfection 1660 Photo */
 	{ USB_DEVICE(0x04b8, 0x0801) }, /* Stylus CX5200 */
 	{ USB_DEVICE(0x04b8, 0x0802) }, /* Stylus CX3200 */
+	/* Siemens */
+	{ USB_DEVICE(0x0681, 0x0005) },	/* ID Mouse Professional */
+	{ USB_DEVICE(0x0681, 0x0010) },	/* Cherry FingerTIP ID Board - Sensor */
 	/* SYSCAN */
 	{ USB_DEVICE(0x0a82, 0x4600) }, /* TravelScan 460/464 */
 	/* Trust */
@@ -289,6 +300,7 @@ static struct usb_device_id scanner_device_ids [] = {
 	{ USB_DEVICE(0x1606, 0x0010) },	/* Astra 1220U */
 	{ USB_DEVICE(0x1606, 0x0030) },	/* Astra 2000U */
 	{ USB_DEVICE(0x1606, 0x0060) }, /* Astra 3400U/3450U */
+	{ USB_DEVICE(0x1606, 0x0070) },	/* Astra 4400 */
 	{ USB_DEVICE(0x1606, 0x0130) }, /* Astra 2100U */
 	{ USB_DEVICE(0x1606, 0x0160) }, /* Astra 5400U */  
 	{ USB_DEVICE(0x1606, 0x0230) },	/* Astra 2200U */
@@ -296,7 +308,8 @@ static struct usb_device_id scanner_device_ids [] = {
 	{ USB_DEVICE(0x04a7, 0x0211) },	/* OneTouch 7600 USB */
 	{ USB_DEVICE(0x04a7, 0x0221) },	/* OneTouch 5300 USB */
 	{ USB_DEVICE(0x04a7, 0x0224) },	/* OneTouch 4800 USB */
-	{ USB_DEVICE(0x04a7, 0x0226) },	/* OneTouch 5300 USB */
+	{ USB_DEVICE(0x04a7, 0x0226) },	/* OneTouch 5800 USB */
+	{ USB_DEVICE(0x04a7, 0x022c) },	/* OneTouch 9020 USB */
 	{ USB_DEVICE(0x04a7, 0x0231) },	/* 6100 USB */
 	{ USB_DEVICE(0x04a7, 0x0311) },	/* 6200 EPP/USB */
 	{ USB_DEVICE(0x04a7, 0x0321) },	/* OneTouch 8100 EPP/USB */

drivers/usb/input/Kconfig

@@ -112,8 +112,8 @@ config USB_MOUSE
 	depends on USB && INPUT
 	---help---
 	  Say Y here only if you are absolutely sure that you don't want
-	  to use the generic HID driver for your USB keyboard and prefer
-	  to use the keyboard in its limited Boot Protocol mode instead.
+	  to use the generic HID driver for your USB mouse and prefer
+	  to use the mouse in its limited Boot Protocol mode instead.
 
 	  This is almost certainly not what you want.  This is mostly
 	  useful for embedded applications or simple mice.

drivers/usb/net/Kconfig

@@ -7,25 +7,6 @@ comment "USB Network adaptors"
 comment "Networking support is needed for USB Networking device support"
 	depends on USB && !NET
 
-config USB_AX8817X_STANDALONE
-	tristate "USB ASIX AX8817X Ethernet device support (EXPERIMENTAL)"
-	depends on USB && NET && EXPERIMENTAL
-	---help---
-	  Say Y if you want to use one of the following 10/100Mps USB
-	  Ethernet devices based on the ASIX AX88172 chip.  Supported
-	  devices are:
-		ASIX AX88172
-		D-Link DUB-E100
-		Hawking UF200
-		Netgear FA120
-
-	  This driver makes the adapter appear as a normal Ethernet interface,
-	  typically on eth0, if it is the only ethernet device, or perhaps on
-	  eth1, if you have a PCI or ISA ethernet card installed.
-
-	  To compile this driver as a module, choose M here: the
-	  module will be called ax8817x.
-
 config USB_CATC
 	tristate "USB CATC NetMate-based Ethernet device support (EXPERIMENTAL)"
 	depends on USB && NET && EXPERIMENTAL

drivers/usb/net/Makefile

@@ -2,7 +2,6 @@
 # Makefile for USB Network drivers
 #
 
-obj-$(CONFIG_USB_AX8817X_STANDALONE)	+= ax8817x.o
 obj-$(CONFIG_USB_CATC)		+= catc.o
 obj-$(CONFIG_USB_KAWETH)	+= kaweth.o
 obj-$(CONFIG_USB_PEGASUS)	+= pegasus.o

drivers/usb/net/Makefile.mii

@@ -2,6 +2,5 @@
 # Makefile for USB Network drivers which require generic MII code.
 #
 
-obj-$(CONFIG_USB_AX8817X)	+= mii.o
 obj-$(CONFIG_USB_PEGASUS)	+= mii.o
 obj-$(CONFIG_USB_USBNET)	+= mii.o

drivers/usb/serial/digi_acceleport.c

@@ -594,8 +594,6 @@ static inline long cond_wait_interruptible_timeout_irqrestore(
 
 	timeout = schedule_timeout(timeout);
 
-	set_current_state( TASK_RUNNING );
-
 	remove_wait_queue( q, &wait );
 
 	return( timeout );

drivers/usb/serial/ftdi_sio.c

@@ -17,6 +17,11 @@
  * See http://ftdi-usb-sio.sourceforge.net for upto date testing info
  *	and extra documentation
  *
+ * (21/Sep/2003) Ian Abbott
+ *      Added VID/PID for Omnidirectional Control Technology US101 USB to
+ *      RS-232 adapter (also rebadged as Dick Smith Electronics XH6381).
+ *      VID/PID supplied by Donald Gordon.
+ *
  * (19/Aug/2003) Ian Abbott
  *      Freed urb's transfer buffer in write bulk callback.
  *      Omitted some paranoid checks in write bulk callback that don't matter.
@@ -334,6 +339,7 @@ static struct usb_device_id id_table_8U232AM [] = {
 	{ USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_7_PID, 0, 0x3ff) },
 	{ USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_8_PID, 0, 0x3ff) },
 	{ USB_DEVICE_VER(IDTECH_VID, IDTECH_IDT1221U_PID, 0, 0x3ff) },
+	{ USB_DEVICE_VER(OCT_VID, OCT_US101_PID, 0, 0x3ff) },
 	{ }						/* Terminating entry */
 };
 
@@ -406,6 +412,7 @@ static struct usb_device_id id_table_FT232BM [] = {
 	{ USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_7_PID, 0x400, 0xffff) },
 	{ USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_8_PID, 0x400, 0xffff) },
 	{ USB_DEVICE_VER(IDTECH_VID, IDTECH_IDT1221U_PID, 0x400, 0xffff) },
+	{ USB_DEVICE_VER(OCT_VID, OCT_US101_PID, 0x400, 0xffff) },
 	{ }						/* Terminating entry */
 };
 
@@ -491,6 +498,7 @@ static struct usb_device_id id_table_combined [] = {
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_7_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_8_PID) },
 	{ USB_DEVICE(IDTECH_VID, IDTECH_IDT1221U_PID) },
+	{ USB_DEVICE(OCT_VID, OCT_US101_PID) },
 	{ USB_DEVICE_VER(FTDI_VID, FTDI_HE_TIRA1_PID, 0x400, 0xffff) },
 	{ USB_DEVICE(FTDI_VID, FTDI_USB_UIRT_PID) },
 	{ }						/* Terminating entry */

drivers/usb/serial/ftdi_sio.h

@@ -133,6 +133,13 @@
 #define IDTECH_VID		0x0ACD	/* ID TECH Vendor ID */
 #define IDTECH_IDT1221U_PID	0x0300	/* IDT1221U USB to RS-232 adapter */
 
+/*
+ * Definitions for Omnidirectional Control Technology, Inc. devices
+ */
+#define OCT_VID			0x0B39	/* OCT vendor ID */
+/* Note: OCT US101 is also rebadged as Dick Smith Electronics (NZ) XH6381 */
+#define OCT_US101_PID		0x0421	/* OCT US101 USB to RS-232 */
+
 /* Commands */
 #define FTDI_SIO_RESET 		0 /* Reset the port */
 #define FTDI_SIO_MODEM_CTRL 	1 /* Set the modem control register */

drivers/usb/serial/usb-serial.c

@@ -1019,10 +1019,10 @@ int usb_serial_probe(struct usb_interface *interface,
 		retval = type->probe (serial, id_pattern);
 		module_put(type->owner);
 
-		if (retval < 0) {
+		if (retval) {
 			dbg ("sub driver rejected device");
 			kfree (serial);
-			return -ENODEV;
+			return retval;
 		}
 	}
 

drivers/usb/storage/transport.c

@@ -1074,7 +1074,6 @@ static int usb_stor_reset_common(struct us_data *us,
 	up(&us->dev_semaphore);
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	schedule_timeout(HZ*6);
-	set_current_state(TASK_RUNNING);
 	down(&us->dev_semaphore);
 	if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
 		US_DEBUGP("Reset interrupted by disconnect\n");