Skip to contentSkip to conversation

usb: add sysfs configuration interface for CP2101

PATCH In review Dirk Eibach 5 participants 15 messages Feb 29, 2008 – Apr 9, 2008

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 usb: add sysfs configuration interface for CP2101

From: Dirk Eibach <[email protected]>

The usb configuration data for the Silabs CP2101 usb to uart bridge controller can be customized:
- Vendor ID
- Product ID
- Power Descriptor
- Release Number
- Serial Number
- Product Description String

Silabs provides a windows-only tool to do that.
Since we use linux-only machines in our production-environment, we have no proper way to customize the chips for our purpose.
So I added sysfs configuration support to the linux driver.

---

drivers/usb/serial/cp2101.c +283 -0
diff -purN linux-2.6.24/drivers/usb/serial/cp2101.c linux-2.6.24-diff/drivers/usb/serial/cp2101.c
@@ -18,6 +18,8 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/platform_device.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/tty.h>
@@ -52,6 +54,8 @@ static void cp2101_shutdown(struct usb_s
 
 static int debug;
 
+bool enable_config = false;
+
 static struct usb_device_id id_table [] = {
 	{ USB_DEVICE(0x08e6, 0x5501) }, /* Gemalto Prox-PU/CU contactless smartcard reader */
 	{ USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */
@@ -125,6 +129,7 @@ static struct usb_serial_driver cp2101_d
 #define CP2101_CONTROL		0x07	/* Flow control line states */
 #define CP2101_MODEMCTL		0x13	/* Modem controls */
 #define CP2101_CONFIG_6		0x19	/* 6 bytes of config data ??? */
+#define CP2101_EEPROM		0xFF	/* write configuration eeprom */
 
 /* CP2101_UART */
 #define UART_ENABLE		0x0001
@@ -167,6 +172,17 @@ static struct usb_serial_driver cp2101_d
 #define CONTROL_WRITE_DTR	0x0100
 #define CONTROL_WRITE_RTS	0x0200
 
+/* CP2101 CONFIGURATION EEPROM */
+#define EEPROM_RELOAD		0x0008
+#define EEPROM_VID		0x3701
+#define EEPROM_PID		0x3702
+#define EEPROM_PRODUCTSTRING	0x3703
+#define EEPROM_SERIALNUMBER	0x3704
+#define EEPROM_POWER_ATTRIB	0x3705
+#define EEPROM_MAX_POWER	0x3706
+#define EEPROM_RELEASE_VERSION	0x3707
+#define EEPROM_LOCK		0x370a
+
 /*
  * cp2101_get_config
  * Reads from the CP2101 configuration registers
@@ -704,11 +720,262 @@ static void cp2101_break_ctl (struct usb
 	cp2101_set_config(port, CP2101_BREAK, &state, 2);
 }
 
+static ssize_t write_reload(struct device *dev, struct device_attribute *attr,
+	const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	/* writing "0" does not trigger */
+	if (!simple_strtoul(buf, NULL, 0))
+		return count;
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_RELOAD,
+		0, NULL, 0, 300);
+
+	return count;
+}
+
+static DEVICE_ATTR(reload, S_IWUGO, NULL, write_reload);
+
+static ssize_t write_vid(struct device *dev, struct device_attribute *attr,
+	const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long vid = simple_strtoul(buf, NULL, 0);
+
+	if (!vid || vid > 0xffff)
+		return -EINVAL;
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_VID,
+		vid, NULL, 0, 300);
+
+	return count;
+}
+
+static DEVICE_ATTR(vid, S_IWUGO, NULL, write_vid);
+
+static ssize_t write_pid(struct device *dev, struct device_attribute *attr,
+	const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long pid = simple_strtoul(buf, NULL, 0);
+
+	if (!pid || pid > 0xffff)
+		return -EINVAL;
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_PID,
+		pid, NULL, 0, 300);
+
+	return count;
+}
+
+static DEVICE_ATTR(pid, S_IWUGO, NULL, write_pid);
+
+static ssize_t write_serialnumber(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t count)
+{
+	int result;
+	unsigned int k;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+	u8 serial_stringsize = 2 + 2*count;
+	char serial[serial_stringsize];
+
+	if (count > 63)
+		return -EINVAL;
+
+	serial[0] = serial_stringsize;
+	serial[1] = USB_DT_STRING;
+
+	/* convert to utf-16 */
+	for (k = 0; k < count; ++k) {
+		serial[2+2*k] = buf[k];
+		serial[2+2*k+1] = 0;
+	}
+
+	result = usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_SERIALNUMBER,
+		0, serial, sizeof(serial), 300);
+
+	if (result != serial_stringsize)
+		return -EIO;
+
+	return count;
+}
+
+static DEVICE_ATTR(serialnumber, S_IWUGO, NULL, write_serialnumber);
+
+
+static ssize_t write_productstring(struct device *dev,
+	struct device_attribute *attr,	const char *buf, size_t count)
+{
+	int result;
+	unsigned int k;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+	u8 product_stringsize = 2 + 2*count;
+	char product[product_stringsize];
+
+	if (count > 126)
+		return -EINVAL;
+
+	product[0] = product_stringsize;
+	product[1] = USB_DT_STRING;
+
+	/* convert to utf-16 */
+	for (k = 0; k < count; ++k) {
+		product[2+2*k] = buf[k];
+		product[2+2*k+1] = 0;
+	}
+
+	result = usb_control_msg(usbdev,
+			usb_sndctrlpipe(usbdev, 0),
+			CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE,
+			EEPROM_PRODUCTSTRING, 0,
+			product, sizeof(product), 300);
+
+	if (result != product_stringsize)
+		return -EIO;
+
+	return count;
+}
+
+static DEVICE_ATTR(productstring, S_IWUGO, NULL, write_productstring);
+
+static ssize_t write_self_powered(struct device *dev,
+	struct device_attribute *attr,	const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long self_powered = simple_strtoul(buf, NULL, 0);
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_POWER_ATTRIB,
+		self_powered ? 0x00c0 : 0x0080, NULL, 0, 300);
+
+	return count;
+}
+
+static DEVICE_ATTR(self_powered, S_IWUGO, NULL, write_self_powered);
+
+static ssize_t write_max_power(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long max_power = simple_strtoul(buf, NULL, 0);
+
+	if (!max_power || max_power > 0xff)
+		return -EINVAL;
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_MAX_POWER,
+		max_power, NULL, 0, 300);
+
+	return count;
+}
+
+static DEVICE_ATTR(max_power, S_IWUGO, NULL, write_max_power);
+
+static ssize_t write_release_version(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long release_version = simple_strtoul(buf, NULL, 0);
+
+	if (release_version > 0xffff)
+		return -EINVAL;
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_RELEASE_VERSION,
+		release_version, NULL, 0, 300);
+
+	return count;
+}
+
+static DEVICE_ATTR(release_version, S_IWUGO, NULL, write_release_version);
+
+static ssize_t write_lock_forever(struct device *dev,
+	struct device_attribute *attr,	const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long lock = simple_strtoul(buf, NULL, 0);
+
+	/* be really, really sure to know what you are doing here */
+	if (lock != 0xabadbabe)
+		return -EINVAL;
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_LOCK,
+		0x00f0, NULL, 0, 300);
+
+	return count;
+}
+
+static DEVICE_ATTR(lock_forever, S_IWUGO, NULL, write_lock_forever);
+
 static int cp2101_startup (struct usb_serial *serial)
 {
+	int err;
+
 	/* CP2101 buffers behave strangely unless device is reset */
 	usb_reset_device(serial->dev);
+
+	if (!enable_config)
+		return 0;
+
+	err = device_create_file(&serial->dev->dev, &dev_attr_reload);
+	if (err) goto out;
+	err = device_create_file(&serial->dev->dev, &dev_attr_vid);
+	if (err) goto out_reload;
+	err = device_create_file(&serial->dev->dev, &dev_attr_pid);
+	if (err) goto out_vid;
+	err = device_create_file(&serial->dev->dev, &dev_attr_productstring);
+	if (err) goto out_pid;
+	err = device_create_file(&serial->dev->dev, &dev_attr_serialnumber);
+	if (err) goto out_productstring;
+	err = device_create_file(&serial->dev->dev, &dev_attr_self_powered);
+	if (err) goto out_serialnumber;
+	err = device_create_file(&serial->dev->dev, &dev_attr_max_power);
+	if (err) goto out_self_powered;
+	err = device_create_file(&serial->dev->dev, &dev_attr_release_version);
+	if (err) goto out_max_power;
+	err = device_create_file(&serial->dev->dev, &dev_attr_lock_forever);
+	if (err) goto out_release_version;
+
 	return 0;
+
+out_release_version:
+	device_remove_file(&serial->dev->dev, &dev_attr_release_version);
+out_max_power:
+	device_remove_file(&serial->dev->dev, &dev_attr_max_power);
+out_self_powered:
+	device_remove_file(&serial->dev->dev, &dev_attr_self_powered);
+out_serialnumber:
+	device_remove_file(&serial->dev->dev, &dev_attr_serialnumber);
+out_productstring:
+	device_remove_file(&serial->dev->dev, &dev_attr_productstring);
+out_pid:
+	device_remove_file(&serial->dev->dev, &dev_attr_pid);
+out_vid:
+	device_remove_file(&serial->dev->dev, &dev_attr_vid);
+out_reload:
+	device_remove_file(&serial->dev->dev, &dev_attr_reload);
+out:
+	return err;
 }
 
 static void cp2101_shutdown (struct usb_serial *serial)
@@ -721,6 +988,19 @@ static void cp2101_shutdown (struct usb_
 	for (i=0; i < serial->num_ports; ++i) {
 		cp2101_cleanup(serial->port[i]);
 	}
+
+	if (!enable_config)
+		return;
+
+	device_remove_file(&serial->dev->dev, &dev_attr_reload);
+	device_remove_file(&serial->dev->dev, &dev_attr_vid);
+	device_remove_file(&serial->dev->dev, &dev_attr_pid);
+	device_remove_file(&serial->dev->dev, &dev_attr_productstring);
+	device_remove_file(&serial->dev->dev, &dev_attr_serialnumber);
+	device_remove_file(&serial->dev->dev, &dev_attr_self_powered);
+	device_remove_file(&serial->dev->dev, &dev_attr_max_power);
+	device_remove_file(&serial->dev->dev, &dev_attr_release_version);
+	device_remove_file(&serial->dev->dev, &dev_attr_lock_forever);
 }
 
 static int __init cp2101_init (void)
@@ -758,3 +1038,6 @@ MODULE_LICENSE("GPL");
 
 module_param(debug, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Enable verbose debugging messages");
+
+module_param(enable_config, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(enable_config, "Enable sysfs access to configuration eeprom.");
drivers/usb/serial/cp2101.c.orig +760 -0

760 lines not on this page · raw message

#1 lore raw
Quoted 11 lines · [email protected] wrote:

From: Dirk Eibach <[email protected]>

The usb configuration data for the Silabs CP2101 usb to uart bridge controller can be customized:
- Vendor ID
- Product ID
- Power Descriptor
- Release Number
- Serial Number
- Product Description String

Quoted 7 lines

Silabs provides a windows-only tool to do that.
Since we use linux-only machines in our production-environment, we have no proper way to customize the chips for our purpose.
So I added sysfs configuration support to the linux driver.

---

Sorry, I have to resubmit the patch, because a backup copy crept in...

drivers/usb/serial/cp2101.c +283 -0
diff -purN linux-2.6.24/drivers/usb/serial/cp2101.c linux-2.6.24-diff/drivers/usb/serial/cp2101.c
@@ -18,6 +18,8 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/platform_device.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/tty.h>
@@ -52,6 +54,8 @@ static void cp2101_shutdown(struct usb_s
 
 static int debug;
 
+bool enable_config = false;
+
 static struct usb_device_id id_table [] = {
 	{ USB_DEVICE(0x08e6, 0x5501) }, /* Gemalto Prox-PU/CU contactless smartcard reader */
 	{ USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */
@@ -125,6 +129,7 @@ static struct usb_serial_driver cp2101_d
 #define CP2101_CONTROL		0x07	/* Flow control line states */
 #define CP2101_MODEMCTL		0x13	/* Modem controls */
 #define CP2101_CONFIG_6		0x19	/* 6 bytes of config data ??? */
+#define CP2101_EEPROM		0xFF	/* write configuration eeprom */
 
 /* CP2101_UART */
 #define UART_ENABLE		0x0001
@@ -167,6 +172,17 @@ static struct usb_serial_driver cp2101_d
 #define CONTROL_WRITE_DTR	0x0100
 #define CONTROL_WRITE_RTS	0x0200
 
+/* CP2101 CONFIGURATION EEPROM */
+#define EEPROM_RELOAD		0x0008
+#define EEPROM_VID		0x3701
+#define EEPROM_PID		0x3702
+#define EEPROM_PRODUCTSTRING	0x3703
+#define EEPROM_SERIALNUMBER	0x3704
+#define EEPROM_POWER_ATTRIB	0x3705
+#define EEPROM_MAX_POWER	0x3706
+#define EEPROM_RELEASE_VERSION	0x3707
+#define EEPROM_LOCK		0x370a
+
 /*
  * cp2101_get_config
  * Reads from the CP2101 configuration registers
@@ -704,11 +720,262 @@ static void cp2101_break_ctl (struct usb
 	cp2101_set_config(port, CP2101_BREAK, &state, 2);
 }
 
+static ssize_t write_reload(struct device *dev, struct device_attribute *attr,
+	const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	/* writing "0" does not trigger */
+	if (!simple_strtoul(buf, NULL, 0))
+		return count;
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_RELOAD,
+		0, NULL, 0, 300);
+
+	return count;
+}
+
+static DEVICE_ATTR(reload, S_IWUGO, NULL, write_reload);
+
+static ssize_t write_vid(struct device *dev, struct device_attribute *attr,
+	const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long vid = simple_strtoul(buf, NULL, 0);
+
+	if (!vid || vid > 0xffff)
+		return -EINVAL;
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_VID,
+		vid, NULL, 0, 300);
+
+	return count;
+}
+
+static DEVICE_ATTR(vid, S_IWUGO, NULL, write_vid);
+
+static ssize_t write_pid(struct device *dev, struct device_attribute *attr,
+	const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long pid = simple_strtoul(buf, NULL, 0);
+
+	if (!pid || pid > 0xffff)
+		return -EINVAL;
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_PID,
+		pid, NULL, 0, 300);
+
+	return count;
+}
+
+static DEVICE_ATTR(pid, S_IWUGO, NULL, write_pid);
+
+static ssize_t write_serialnumber(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t count)
+{
+	int result;
+	unsigned int k;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+	u8 serial_stringsize = 2 + 2*count;
+	char serial[serial_stringsize];
+
+	if (count > 63)
+		return -EINVAL;
+
+	serial[0] = serial_stringsize;
+	serial[1] = USB_DT_STRING;
+
+	/* convert to utf-16 */
+	for (k = 0; k < count; ++k) {
+		serial[2+2*k] = buf[k];
+		serial[2+2*k+1] = 0;
+	}
+
+	result = usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_SERIALNUMBER,
+		0, serial, sizeof(serial), 300);
+
+	if (result != serial_stringsize)
+		return -EIO;
+
+	return count;
+}
+
+static DEVICE_ATTR(serialnumber, S_IWUGO, NULL, write_serialnumber);
+
+
+static ssize_t write_productstring(struct device *dev,
+	struct device_attribute *attr,	const char *buf, size_t count)
+{
+	int result;
+	unsigned int k;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+	u8 product_stringsize = 2 + 2*count;
+	char product[product_stringsize];
+
+	if (count > 126)
+		return -EINVAL;
+
+	product[0] = product_stringsize;
+	product[1] = USB_DT_STRING;
+
+	/* convert to utf-16 */
+	for (k = 0; k < count; ++k) {
+		product[2+2*k] = buf[k];
+		product[2+2*k+1] = 0;
+	}
+
+	result = usb_control_msg(usbdev,
+			usb_sndctrlpipe(usbdev, 0),
+			CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE,
+			EEPROM_PRODUCTSTRING, 0,
+			product, sizeof(product), 300);
+
+	if (result != product_stringsize)
+		return -EIO;
+
+	return count;
+}
+
+static DEVICE_ATTR(productstring, S_IWUGO, NULL, write_productstring);
+
+static ssize_t write_self_powered(struct device *dev,
+	struct device_attribute *attr,	const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long self_powered = simple_strtoul(buf, NULL, 0);
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_POWER_ATTRIB,
+		self_powered ? 0x00c0 : 0x0080, NULL, 0, 300);
+
+	return count;
+}
+
+static DEVICE_ATTR(self_powered, S_IWUGO, NULL, write_self_powered);
+
+static ssize_t write_max_power(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long max_power = simple_strtoul(buf, NULL, 0);
+
+	if (!max_power || max_power > 0xff)
+		return -EINVAL;
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_MAX_POWER,
+		max_power, NULL, 0, 300);
+
+	return count;
+}
+
+static DEVICE_ATTR(max_power, S_IWUGO, NULL, write_max_power);
+
+static ssize_t write_release_version(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long release_version = simple_strtoul(buf, NULL, 0);
+
+	if (release_version > 0xffff)
+		return -EINVAL;
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_RELEASE_VERSION,
+		release_version, NULL, 0, 300);
+
+	return count;
+}
+
+static DEVICE_ATTR(release_version, S_IWUGO, NULL, write_release_version);
+
+static ssize_t write_lock_forever(struct device *dev,
+	struct device_attribute *attr,	const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long lock = simple_strtoul(buf, NULL, 0);
+
+	/* be really, really sure to know what you are doing here */
+	if (lock != 0xabadbabe)
+		return -EINVAL;
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_LOCK,
+		0x00f0, NULL, 0, 300);
+
+	return count;
+}
+
+static DEVICE_ATTR(lock_forever, S_IWUGO, NULL, write_lock_forever);
+
 static int cp2101_startup (struct usb_serial *serial)
 {
+	int err;
+
 	/* CP2101 buffers behave strangely unless device is reset */
 	usb_reset_device(serial->dev);
+
+	if (!enable_config)
+		return 0;
+
+	err = device_create_file(&serial->dev->dev, &dev_attr_reload);
+	if (err) goto out;
+	err = device_create_file(&serial->dev->dev, &dev_attr_vid);
+	if (err) goto out_reload;
+	err = device_create_file(&serial->dev->dev, &dev_attr_pid);
+	if (err) goto out_vid;
+	err = device_create_file(&serial->dev->dev, &dev_attr_productstring);
+	if (err) goto out_pid;
+	err = device_create_file(&serial->dev->dev, &dev_attr_serialnumber);
+	if (err) goto out_productstring;
+	err = device_create_file(&serial->dev->dev, &dev_attr_self_powered);
+	if (err) goto out_serialnumber;
+	err = device_create_file(&serial->dev->dev, &dev_attr_max_power);
+	if (err) goto out_self_powered;
+	err = device_create_file(&serial->dev->dev, &dev_attr_release_version);
+	if (err) goto out_max_power;
+	err = device_create_file(&serial->dev->dev, &dev_attr_lock_forever);
+	if (err) goto out_release_version;
+
 	return 0;
+
+out_release_version:
+	device_remove_file(&serial->dev->dev, &dev_attr_release_version);
+out_max_power:
+	device_remove_file(&serial->dev->dev, &dev_attr_max_power);
+out_self_powered:
+	device_remove_file(&serial->dev->dev, &dev_attr_self_powered);
+out_serialnumber:
+	device_remove_file(&serial->dev->dev, &dev_attr_serialnumber);
+out_productstring:
+	device_remove_file(&serial->dev->dev, &dev_attr_productstring);
+out_pid:
+	device_remove_file(&serial->dev->dev, &dev_attr_pid);
+out_vid:
+	device_remove_file(&serial->dev->dev, &dev_attr_vid);
+out_reload:
+	device_remove_file(&serial->dev->dev, &dev_attr_reload);
+out:
+	return err;
 }
 
 static void cp2101_shutdown (struct usb_serial *serial)
@@ -721,6 +988,19 @@ static void cp2101_shutdown (struct usb_
 	for (i=0; i < serial->num_ports; ++i) {
 		cp2101_cleanup(serial->port[i]);
 	}
+
+	if (!enable_config)
+		return;
+
+	device_remove_file(&serial->dev->dev, &dev_attr_reload);
+	device_remove_file(&serial->dev->dev, &dev_attr_vid);
+	device_remove_file(&serial->dev->dev, &dev_attr_pid);
+	device_remove_file(&serial->dev->dev, &dev_attr_productstring);
+	device_remove_file(&serial->dev->dev, &dev_attr_serialnumber);
+	device_remove_file(&serial->dev->dev, &dev_attr_self_powered);
+	device_remove_file(&serial->dev->dev, &dev_attr_max_power);
+	device_remove_file(&serial->dev->dev, &dev_attr_release_version);
+	device_remove_file(&serial->dev->dev, &dev_attr_lock_forever);
 }
 
 static int __init cp2101_init (void)
@@ -758,3 +1038,6 @@ MODULE_LICENSE("GPL");
 
 module_param(debug, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Enable verbose debugging messages");
+
+module_param(enable_config, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(enable_config, "Enable sysfs access to configuration eeprom.");
#2 lore raw
In reply to Dirk Eibach
Quoted 11 lines · On Fri, 29 Feb 2008 10:02:18 +0100 Dirk Eibach <[email protected]> wrote:

From: Dirk Eibach <[email protected]>

The usb configuration data for the Silabs CP2101 usb to uart bridge controller can be customized:
- Vendor ID
- Product ID
- Power Descriptor
- Release Number
- Serial Number
- Product Description String

Quoted 5 lines

Silabs provides a windows-only tool to do that.
Since we use linux-only machines in our production-environment, we have no proper way to customize the chips for our purpose.
So I added sysfs configuration support to the linux driver.

Thanks.

Quoted 1 line

From where do our users get the information which they are to write into

these sysfs files?

Please pass your diff through scripts/checkpatch.pl and address the (valid) errors which it reports.

drivers/usb/serial/cp2101.c static void cp2101_break_ctl (struct usb · line 747

Quoted 6 lines
drivers/usb/serial/cp2101.c +6 -0
+static ssize_t write_vid(struct device *dev, struct device_attribute *attr,
+	const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long vid = simple_strtoul(buf, NULL, 0);

If a user writes "12bucklemyshoe" into one of your sysfs files the kernel will treat this as 12, which is poor form.

We have a new strict_strtoul() (and related functions) which will perform proper checking for a valid number. Please use that interface.

Andy, this is going to happen so much that a "should you have used strict_strtoul?" warning in checkpatch would reduce my email output.

drivers/usb/serial/cp2101.c static void cp2101_break_ctl (struct usb · line 755

Quoted 7 lines
drivers/usb/serial/cp2101.c +7 -0
+	if (!vid || vid > 0xffff)
+		return -EINVAL;
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_VID,
+		vid, NULL, 0, 300);

usb_control_msg() can return an error, but this driver doesn't check for that in several places.

Quoted 12 lines
drivers/usb/serial/cp2101.c +12 -0
+	return count;
+}
+
+static DEVICE_ATTR(vid, S_IWUGO, NULL, write_vid);
+
+static ssize_t write_pid(struct device *dev, struct device_attribute *attr,
+	const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long pid = simple_strtoul(buf, NULL, 0);
+

drivers/usb/serial/cp2101.c static void cp2101_break_ctl (struct usb · line 778

Quoted 10 lines
drivers/usb/serial/cp2101.c +10 -0
+	if (!pid || pid > 0xffff)
+		return -EINVAL;
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_PID,
+		pid, NULL, 0, 300);
+
+	return count;
+}

<gets worried>

Oh. Here, "pid" means product ID, not process ID. A little comment over these functions would be nice ;)

drivers/usb/serial/cp2101.c static void cp2101_break_ctl (struct usb · line 792

Quoted 13 lines
drivers/usb/serial/cp2101.c +13 -0
+static DEVICE_ATTR(pid, S_IWUGO, NULL, write_pid);
+
+static ssize_t write_serialnumber(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t count)
+{
+	int result;
+	unsigned int k;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+	u8 serial_stringsize = 2 + 2*count;
+	char serial[serial_stringsize];
+
+	if (count > 63)
+		return -EINVAL;

uh-oh. serial[] is dynamically allocated on the stack _before_ we've checked `count'. Methinks we've just give people a way to allocate 8GB of kernel stack, which won't work terribly well.

I suggest a switch to kmalloc().

drivers/usb/serial/cp2101.c static void cp2101_break_ctl (struct usb · line 801

Quoted 8 lines
drivers/usb/serial/cp2101.c +8 -0
+	serial[0] = serial_stringsize;
+	serial[1] = USB_DT_STRING;
+
+	/* convert to utf-16 */
+	for (k = 0; k < count; ++k) {
+		serial[2+2*k] = buf[k];
+		serial[2+2*k+1] = 0;
+	}

Are you sure this doesn't run off the end of serial[]?

Quoted 36 lines
drivers/usb/serial/cp2101.c +36 -0
+	result = usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_SERIALNUMBER,
+		0, serial, sizeof(serial), 300);
+
+	if (result != serial_stringsize)
+		return -EIO;
+
+	return count;
+}
+
+static DEVICE_ATTR(serialnumber, S_IWUGO, NULL, write_serialnumber);
+
+
+static ssize_t write_productstring(struct device *dev,
+	struct device_attribute *attr,	const char *buf, size_t count)
+{
+	int result;
+	unsigned int k;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+	u8 product_stringsize = 2 + 2*count;
+	char product[product_stringsize];
+
+	if (count > 126)
+		return -EINVAL;
+
+	product[0] = product_stringsize;
+	product[1] = USB_DT_STRING;
+
+	/* convert to utf-16 */
+	for (k = 0; k < count; ++k) {
+		product[2+2*k] = buf[k];
+		product[2+2*k+1] = 0;
+	}
+
+	result = usb_control_msg(usbdev,

drivers/usb/serial/cp2101.c static void cp2101_break_ctl (struct usb · line 848

Quoted 10 lines
drivers/usb/serial/cp2101.c +10 -0
+			usb_sndctrlpipe(usbdev, 0),
+			CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE,
+			EEPROM_PRODUCTSTRING, 0,
+			product, sizeof(product), 300);
+
+	if (result != product_stringsize)
+		return -EIO;
+
+	return count;
+}

dittoes.

Quoted 27 lines
drivers/usb/serial/cp2101.c +24 -0
+static DEVICE_ATTR(productstring, S_IWUGO, NULL, write_productstring);
+
+static ssize_t write_self_powered(struct device *dev,
+	struct device_attribute *attr,	const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long self_powered = simple_strtoul(buf, NULL, 0);
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_POWER_ATTRIB,
+		self_powered ? 0x00c0 : 0x0080, NULL, 0, 300);
+
+	return count;
+}
 
...
 
+static ssize_t write_lock_forever(struct device *dev,
+	struct device_attribute *attr,	const char *buf, size_t count)
+{
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long lock = simple_strtoul(buf, NULL, 0);
+
+	/* be really, really sure to know what you are doing here */

drivers/usb/serial/cp2101.c static void cp2101_break_ctl (struct usb · line 926

Quoted 10 lines
drivers/usb/serial/cp2101.c +10 -0
+	if (lock != 0xabadbabe)
+		return -EINVAL;
+
+	usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_LOCK,
+		0x00f0, NULL, 0, 300);
+
+	return count;
+}

hm, interesting. A bit of interface documetation would be nice.

Quoted 42 lines
drivers/usb/serial/cp2101.c +37 -0
+static DEVICE_ATTR(lock_forever, S_IWUGO, NULL, write_lock_forever);
+
 static int cp2101_startup (struct usb_serial *serial)
 {
+	int err;
+
 	/* CP2101 buffers behave strangely unless device is reset */
 	usb_reset_device(serial->dev);
+
+	if (!enable_config)
+		return 0;
+
+	err = device_create_file(&serial->dev->dev, &dev_attr_reload);
+	if (err) goto out;
+	err = device_create_file(&serial->dev->dev, &dev_attr_vid);
+	if (err) goto out_reload;
+	err = device_create_file(&serial->dev->dev, &dev_attr_pid);
+	if (err) goto out_vid;
+	err = device_create_file(&serial->dev->dev, &dev_attr_productstring);
+	if (err) goto out_pid;
+	err = device_create_file(&serial->dev->dev, &dev_attr_serialnumber);
+	if (err) goto out_productstring;
+	err = device_create_file(&serial->dev->dev, &dev_attr_self_powered);
+	if (err) goto out_serialnumber;
+	err = device_create_file(&serial->dev->dev, &dev_attr_max_power);
+	if (err) goto out_self_powered;
+	err = device_create_file(&serial->dev->dev, &dev_attr_release_version);
+	if (err) goto out_max_power;
+	err = device_create_file(&serial->dev->dev, &dev_attr_lock_forever);
+	if (err) goto out_release_version;
+
 	return 0;
+
+out_release_version:
+	device_remove_file(&serial->dev->dev, &dev_attr_release_version);
+out_max_power:
+	device_remove_file(&serial->dev->dev, &dev_attr_max_power);
+out_self_powered:
+	device_remove_file(&serial->dev->dev, &dev_attr_self_powered);
+out_serialnumber:
+	device_remove_file(&serial->dev->dev, &dev_attr_serialnumber);
+out_productstring:

drivers/usb/serial/cp2101.c static void cp2101_break_ctl (struct usb · line 979

Quoted 10 lines
drivers/usb/serial/cp2101.c +9 -0
+	device_remove_file(&serial->dev->dev, &dev_attr_productstring);
+out_pid:
+	device_remove_file(&serial->dev->dev, &dev_attr_pid);
+out_vid:
+	device_remove_file(&serial->dev->dev, &dev_attr_vid);
+out_reload:
+	device_remove_file(&serial->dev->dev, &dev_attr_reload);
+out:
+	return err;
 }

I think the attribute-group interface will permit you to do this more elegantly.

Quoted 40 lines

static void cp2101_shutdown (struct usb_serial *serial)

drivers/usb/serial/cp2101.c.orig +31 -0
@@ -721,6 +988,19 @@ static void cp2101_shutdown (struct usb_
 	for (i=0; i < serial->num_ports; ++i) {
 		cp2101_cleanup(serial->port[i]);
 	}
+
+	if (!enable_config)
+		return;
+
+	device_remove_file(&serial->dev->dev, &dev_attr_reload);
+	device_remove_file(&serial->dev->dev, &dev_attr_vid);
+	device_remove_file(&serial->dev->dev, &dev_attr_pid);
+	device_remove_file(&serial->dev->dev, &dev_attr_productstring);
+	device_remove_file(&serial->dev->dev, &dev_attr_serialnumber);
+	device_remove_file(&serial->dev->dev, &dev_attr_self_powered);
+	device_remove_file(&serial->dev->dev, &dev_attr_max_power);
+	device_remove_file(&serial->dev->dev, &dev_attr_release_version);
+	device_remove_file(&serial->dev->dev, &dev_attr_lock_forever);
 }
 
...
 
+/*
+ * Silicon Laboratories CP2101/CP2102 USB to RS232 serial adaptor driver
+ *
+ * Copyright (C) 2005 Craig Shelley ([email protected])
+ *
+ *	This program is free software; you can redistribute it and/or
+ *	modify it under the terms of the GNU General Public License version
+ *	2 as published by the Free Software Foundation.
+ *
+ * Support to set flow control line levels using TIOCMGET and TIOCMSET
+ * thanks to Karl Hiramoto [email protected]. RTSCTS hardware flow
+ * control thanks to Munir Nassar [email protected]
+ *
+ * Outstanding Issues:
+ *  Buffers are not flushed when the port is opened.
+ *  Multiple calls to write() may fail with "Resource temporarily unavailable"
+ *
+ */

drivers/usb/serial/cp2101.c.orig static void cp2101_shutdown (struct usb_ · line 28

Quoted 10 lines
drivers/usb/serial/cp2101.c.orig +10 -0
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/usb.h>
+#include <asm/uaccess.h>

Please include linux/foo.h in preference to asm/foo.h when linux/foo.h exists.

checkpatch used to detect this but it got broken.

Quoted 17 lines
drivers/usb/serial/cp2101.c.orig +17 -0
+#include <linux/usb/serial.h>
+
+/*
+ * Version Information
+ */
+#define DRIVER_VERSION "v0.07"
+#define DRIVER_DESC "Silicon Labs CP2101/CP2102 RS232 serial adaptor driver"
+
+/*
+ * Function Prototypes
+ */
+static int cp2101_open(struct usb_serial_port*, struct file*);
+static void cp2101_cleanup(struct usb_serial_port*);
+static void cp2101_close(struct usb_serial_port*, struct file*);
+static void cp2101_get_termios(struct usb_serial_port*);
+static void cp2101_set_termios(struct usb_serial_port*, struct ktermios*);
+static int cp2101_tiocmget (struct usb_serial_port *, struct file *);

drivers/usb/serial/cp2101.c.orig line 55

Quoted 10 lines
drivers/usb/serial/cp2101.c.orig +10 -0
+static int cp2101_tiocmset (struct usb_serial_port *, struct file *,
+		unsigned int, unsigned int);
+static void cp2101_break_ctl(struct usb_serial_port*, int);
+static int cp2101_startup (struct usb_serial *);
+static void cp2101_shutdown(struct usb_serial*);
+
+
+static int debug;
+
+static struct usb_device_id id_table [] = {

This should have been laid out as "id_table[]". checkpatch misses this.

Quoted 38 lines
drivers/usb/serial/cp2101.c.orig +35 -0
+	{ USB_DEVICE(0x08e6, 0x5501) }, /* Gemalto Prox-PU/CU contactless smartcard reader */
+	{ USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */
+	{ USB_DEVICE(0x0FCF, 0x1004) }, /* Dynastream ANT2USB */
+	{ USB_DEVICE(0x10A6, 0xAA26) }, /* Knock-off DCU-11 cable */
+	{ USB_DEVICE(0x10AB, 0x10C5) }, /* Siemens MC60 Cable */
+	{ USB_DEVICE(0x10B5, 0xAC70) }, /* Nokia CA-42 USB */
+	{ USB_DEVICE(0x10C4, 0x803B) }, /* Pololu USB-serial converter */
+	{ USB_DEVICE(0x10C4, 0x8053) }, /* Enfora EDG1228 */
+	{ USB_DEVICE(0x10C4, 0x8066) }, /* Argussoft In-System Programmer */
+	{ USB_DEVICE(0x10C4, 0x807A) }, /* Crumb128 board */
+	{ USB_DEVICE(0x10C4, 0x80CA) }, /* Degree Controls Inc */
+	{ USB_DEVICE(0x10C4, 0x80DD) }, /* Tracient RFID */
+	{ USB_DEVICE(0x10C4, 0x80F6) }, /* Suunto sports instrument */
+	{ USB_DEVICE(0x10C4, 0x813D) }, /* Burnside Telecom Deskmobile */
+	{ USB_DEVICE(0x10C4, 0x814A) }, /* West Mountain Radio RIGblaster P&P */
+	{ USB_DEVICE(0x10C4, 0x814B) }, /* West Mountain Radio RIGtalk */
+	{ USB_DEVICE(0x10C4, 0x815E) }, /* Helicomm IP-Link 1220-DVM */
+	{ USB_DEVICE(0x10C4, 0x81C8) }, /* Lipowsky Industrie Elektronik GmbH, Baby-JTAG */
+	{ USB_DEVICE(0x10C4, 0x81E2) }, /* Lipowsky Industrie Elektronik GmbH, Baby-LIN */
+	{ USB_DEVICE(0x10C4, 0x81E7) }, /* Aerocomm Radio */
+	{ USB_DEVICE(0x10C4, 0x8218) }, /* Lipowsky Industrie Elektronik GmbH, HARP-1 */
+	{ USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */
+	{ USB_DEVICE(0x10C4, 0xEA61) }, /* Silicon Labs factory default */
+	{ USB_DEVICE(0x10C5, 0xEA61) }, /* Silicon Labs MobiData GPRS USB Modem */
+	{ USB_DEVICE(0x13AD, 0x9999) }, /* Baltech card reader */
+	{ USB_DEVICE(0x16D6, 0x0001) }, /* Jablotron serial interface */
+	{ } /* Terminating Entry */
+};
+
 
...
 
+/*
+ * cp2101_get_config
+ * Reads from the CP2101 configuration registers
+ * 'size' is specified in bytes.
+ * 'data' is a pointer to a pre-allocated array of integers large
+ * enough to hold 'size' bytes (with 4 bytes to each integer)

drivers/usb/serial/cp2101.c.orig

Quoted 10 lines
drivers/usb/serial/cp2101.c.orig +10 -0
+ */
+static int cp2101_get_config(struct usb_serial_port* port, u8 request,
+		unsigned int *data, int size)
+{
+	struct usb_serial *serial = port->serial;
+	__le32 *buf;
+	int result, i, length;
+
+	/* Number of integers required to contain the array */
+	length = (((size - 1) | 3) + 1)/4;

That looks tricky. Could we just do ROUND_UP(size, 4)?

drivers/usb/serial/cp2101.c.orig line 199

Quoted 13 lines
drivers/usb/serial/cp2101.c.orig +13 -0
+	buf = kcalloc(length, sizeof(__le32), GFP_KERNEL);
+	if (!buf) {
+		dev_err(&port->dev, "%s - out of memory.\n", __FUNCTION__);
+		return -ENOMEM;
+	}
+
+	/* For get requests, the request number must be incremented */
+	request++;
+
+	/* Issue the request, attempting to read 'size' bytes */
+	result = usb_control_msg (serial->dev,usb_rcvctrlpipe (serial->dev, 0),
+				request, REQTYPE_DEVICE_TO_HOST, 0x0000,
+				0, buf, size, 300);

Please don't pu a space before the function call operator "(".

checkpatch misses this too - I suspect it got confused and bailed out.

drivers/usb/serial/cp2101.c.orig line 202

Quoted 2 lines
drivers/usb/serial/cp2101.c.orig +2 -0
+	/* Convert data into an array of integers */
+	for (i=0; i<length; i++)

spaces around the "=" and the "<" here.

Quoted 19 lines
drivers/usb/serial/cp2101.c.orig +19 -0
+		data[i] = le32_to_cpu(buf[i]);
+
+	kfree(buf);
+
+	if (result != size) {
+		dev_err(&port->dev, "%s - Unable to send config request, "
+				"request=0x%x size=%d result=%d\n",
+				__FUNCTION__, request, size, result);
+		return -EPROTO;
+	}
+
+	return 0;
+}
+
+/*
+ * cp2101_set_config
+ * Writes to the CP2101 configuration registers
+ * Values less than 16 bits wide are sent directly
+ * 'size' is specified in bytes.

drivers/usb/serial/cp2101.c.orig line 231

Quoted 10 lines
drivers/usb/serial/cp2101.c.orig +10 -0
+ */
+static int cp2101_set_config(struct usb_serial_port* port, u8 request,
+		unsigned int *data, int size)
+{
+	struct usb_serial *serial = port->serial;
+	__le32 *buf;
+	int result, i, length;
+
+	/* Number of integers required to contain the array */
+	length = (((size - 1) | 3) + 1)/4;

ROUND_UP?

drivers/usb/serial/cp2101.c.orig line 241

Quoted 9 lines
drivers/usb/serial/cp2101.c.orig +9 -0
+	buf = kmalloc(length * sizeof(__le32), GFP_KERNEL);
+	if (!buf) {
+		dev_err(&port->dev, "%s - out of memory.\n",
+				__FUNCTION__);
+		return -ENOMEM;
+	}
+
+	/* Array of integers into bytes */
+	for (i = 0; i < length; i++)

yes, like that.

Quoted 24 lines
drivers/usb/serial/cp2101.c.orig +24 -0
+		buf[i] = cpu_to_le32(data[i]);
+
+	if (size > 2) {
+		result = usb_control_msg (serial->dev,
+				usb_sndctrlpipe(serial->dev, 0),
+				request, REQTYPE_HOST_TO_DEVICE, 0x0000,
+				0, buf, size, 300);
+	} else {
+		result = usb_control_msg (serial->dev,
+				usb_sndctrlpipe(serial->dev, 0),
+				request, REQTYPE_HOST_TO_DEVICE, data[0],
+				0, NULL, 0, 300);
+	}
+
+	kfree(buf);
+
+	if ((size > 2 && result != size) || result < 0) {
+		dev_err(&port->dev, "%s - Unable to send request, "
+				"request=0x%x size=%d result=%d\n",
+				__FUNCTION__, request, size, result);
+		return -EPROTO;
+	}
+
+	/* Single data value */

drivers/usb/serial/cp2101.c.orig line 284

Quoted 10 lines
drivers/usb/serial/cp2101.c.orig +7 -0
+	result = usb_control_msg (serial->dev,
+			usb_sndctrlpipe(serial->dev, 0),
+			request, REQTYPE_HOST_TO_DEVICE, data[0],
+			0, NULL, 0, 300);
+	return 0;
+}
 
...
 
+static int cp2101_open (struct usb_serial_port *port, struct file *filp)

yes, checkpatch has failed us here.

Quoted 33 lines
drivers/usb/serial/cp2101.c.orig +33 -0
+{
+	struct usb_serial *serial = port->serial;
+	int result;
+
+	dbg("%s - port %d", __FUNCTION__, port->number);
+
+	if (cp2101_set_config_single(port, CP2101_UART, UART_ENABLE)) {
+		dev_err(&port->dev, "%s - Unable to enable UART\n",
+				__FUNCTION__);
+		return -EPROTO;
+	}
+
+	/* Start reading from the device */
+	usb_fill_bulk_urb (port->read_urb, serial->dev,
+			usb_rcvbulkpipe(serial->dev,
+			port->bulk_in_endpointAddress),
+			port->read_urb->transfer_buffer,
+			port->read_urb->transfer_buffer_length,
+			serial->type->read_bulk_callback,
+			port);
+	result = usb_submit_urb(port->read_urb, GFP_KERNEL);
+	if (result) {
+		dev_err(&port->dev, "%s - failed resubmitting read urb, "
+				"error %d\n", __FUNCTION__, result);
+		return result;
+	}
+
+	/* Configure the termios structure */
+	cp2101_get_termios(port);
+
+	/* Set the DTR and RTS pins low */
+	cp2101_tiocmset(port, NULL, TIOCM_DTR | TIOCM_RTS, 0);
+

drivers/usb/serial/cp2101.c.orig line 354

Quoted 10 lines
drivers/usb/serial/cp2101.c.orig +10 -0
+	return 0;
+}
+
+/*
+ * cp2101_get_termios
+ * Reads the baud rate, data bits, parity, stop bits and flow control mode
+ * from the device, corrects any unsupported values, and configures the
+ * termios structure to reflect the state of the device
+ */
+static void cp2101_get_termios (struct usb_serial_port *port)

Please cc Alan Cox <[email protected]> on the next version - he might review the termios stuff for us.

drivers/usb/serial/cp2101.c.orig line 362

Quoted 8 lines
drivers/usb/serial/cp2101.c.orig +8 -0
+{
+	unsigned int cflag, modem_ctl[4];
+	int baud;
+	int bits;
+
+	dbg("%s - port %d", __FUNCTION__, port->number);
+
+	if (!port->tty || !port->tty->termios) {

can this happen?

Quoted 40 lines
drivers/usb/serial/cp2101.c.orig +40 -0
+		dbg("%s - no tty structures", __FUNCTION__);
+		return;
+	}
+
+	cp2101_get_config(port, CP2101_BAUDRATE, &baud, 2);
+	/* Convert to baudrate */
+	if (baud)
+		baud = BAUD_RATE_GEN_FREQ / baud;
+
+	dbg("%s - baud rate = %d", __FUNCTION__, baud);
+
+	tty_encode_baud_rate(port->tty, baud, baud);
+	cflag = port->tty->termios->c_cflag;
+
+	cp2101_get_config(port, CP2101_BITS, &bits, 2);
+	cflag &= ~CSIZE;
+	switch(bits & BITS_DATA_MASK) {
+		case BITS_DATA_5:
+			dbg("%s - data bits = 5", __FUNCTION__);
+			cflag |= CS5;
+			break;
+		case BITS_DATA_6:
+			dbg("%s - data bits = 6", __FUNCTION__);
+			cflag |= CS6;
+			break;
+		case BITS_DATA_7:
+			dbg("%s - data bits = 7", __FUNCTION__);
+			cflag |= CS7;
+			break;
+		case BITS_DATA_8:
+			dbg("%s - data bits = 8", __FUNCTION__);
+			cflag |= CS8;
+			break;
+		case BITS_DATA_9:
+			dbg("%s - data bits = 9 (not supported, "
+					"using 8 data bits)", __FUNCTION__);
+			cflag |= CS8;
+			bits &= ~BITS_DATA_MASK;
+			bits |= BITS_DATA_8;
+			cp2101_set_config(port, CP2101_BITS, &bits, 2);

drivers/usb/serial/cp2101.c.orig line 412

Quoted 10 lines
drivers/usb/serial/cp2101.c.orig +10 -0
+			break;
+		default:
+			dbg("%s - Unknown number of data bits, "
+					"using 8", __FUNCTION__);
+			cflag |= CS8;
+			bits &= ~BITS_DATA_MASK;
+			bits |= BITS_DATA_8;
+			cp2101_set_config(port, CP2101_BITS, &bits, 2);
+			break;
+	}

We normally indent the switch body one tabsyop less than this.

I'll stop emulating checkpatch now - let's work out why it failed, get that fixed and then please run it.

#3 lore raw

So here is a new try.

---

drivers/usb/serial/cp2101.c +303 -1
diff -purN linux-2.6.24/drivers/usb/serial/cp2101.c linux-2.6.24-diff/drivers/usb/serial/cp2101.c
@@ -18,6 +18,8 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/platform_device.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/tty.h>
@@ -52,6 +54,8 @@ static void cp2101_shutdown(struct usb_s
 
 static int debug;
 
+static int enable_config = false;
+
 static struct usb_device_id id_table [] = {
 	{ USB_DEVICE(0x08e6, 0x5501) }, /* Gemalto Prox-PU/CU contactless smartcard reader */
 	{ USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */
@@ -125,6 +129,7 @@ static struct usb_serial_driver cp2101_d
 #define CP2101_CONTROL		0x07	/* Flow control line states */
 #define CP2101_MODEMCTL		0x13	/* Modem controls */
 #define CP2101_CONFIG_6		0x19	/* 6 bytes of config data ??? */
+#define CP2101_EEPROM		0xFF	/* write configuration eeprom */
 
 /* CP2101_UART */
 #define UART_ENABLE		0x0001
@@ -167,6 +172,20 @@ static struct usb_serial_driver cp2101_d
 #define CONTROL_WRITE_DTR	0x0100
 #define CONTROL_WRITE_RTS	0x0200
 
+/* CP2101 CONFIGURATION EEPROM */
+#define EEPROM_RELOAD		0x0008
+#define EEPROM_VENDOR_ID	0x3701
+#define EEPROM_PRODUCT_ID	0x3702
+#define EEPROM_PRODUCTSTRING	0x3703
+#define EEPROM_SERIALNUMBER	0x3704
+#define EEPROM_POWER_ATTRIB	0x3705
+#define EEPROM_MAX_POWER	0x3706
+#define EEPROM_RELEASE_VERSION	0x3707
+#define EEPROM_LOCK		0x370a
+
+#define SERIALNUMBER_MAX_CHARS	63
+#define PRODUCTSTRING_MAX_CHARS	126
+
 /*
  * cp2101_get_config
  * Reads from the CP2101 configuration registers
@@ -704,11 +723,286 @@ static void cp2101_break_ctl (struct usb
 	cp2101_set_config(port, CP2101_BREAK, &state, 2);
 }
 
+/*
+ * When loaded with module parameter "enable_config=1" the driver offers the
+ * following sysfs attributes to customize USB configuration data:
+ * reload: write "1" to reboot CP210x and activate the new configuration
+ * vendor_id: write 16 bit value to set
+ * product_id: write 16 bit value to set
+ * productstring: write up to 126 characters to set
+ * serialnumber: write up to 63 characters to set
+ * self_powered: write "1" to set, "0" to unset
+ * max_power: write 8 bit value (unit 2 mA) to set
+ * release_version: write 16 bit BCD-value to set (0x1234 => version 12.34)
+ * lock_forever: write 0xabadbabe to lock the settings permanently
+ */
+
+static ssize_t write_reload(struct device *dev, struct device_attribute *attr,
+	const char *buf, size_t count)
+{
+	int result;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	/* writing "0" does not trigger */
+	if (!strict_strtoul(buf, NULL, 0))
+		return count;
+
+	result = usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_RELOAD,
+		0, NULL, 0, 300);
+
+	/* this request is expected to fail because cp210x reboots */
+
+	return count;
+}
+
+static DEVICE_ATTR(reload, S_IWUGO, NULL, write_reload);
+
+static ssize_t write_vendor_id(struct device *dev, struct device_attribute *attr,
+	const char *buf, size_t count)
+{
+	int result;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long vendor_id = strict_strtoul(buf, NULL, 0);
+
+	if (!vendor_id || vendor_id > 0xffff)
+		return -EINVAL;
+
+	result = usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_VENDOR_ID,
+		vendor_id, NULL, 0, 300);
+
+	if (result)
+		return -EIO;
+
+	return count;
+}
+
+static DEVICE_ATTR(vendor_id, S_IWUGO, NULL, write_vendor_id);
+
+static ssize_t write_product_id(struct device *dev, struct device_attribute *attr,
+	const char *buf, size_t count)
+{
+	int result;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long product_id = strict_strtoul(buf, NULL, 0);
+
+	if (!product_id || product_id > 0xffff)
+		return -EINVAL;
+
+	result = usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_PRODUCT_ID,
+		product_id, NULL, 0, 300);
+
+	if (result)
+		return -EIO;
+
+	return count;
+}
+
+static DEVICE_ATTR(product_id, S_IWUGO, NULL, write_product_id);
+
+static ssize_t write_serialnumber(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t count)
+{
+	int result;
+	unsigned int k;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+	u8 serial_stringsize = 2 + 2*count;
+	char serial[2 + 2*SERIALNUMBER_MAX_CHARS];
+
+	if (count > SERIALNUMBER_MAX_CHARS)
+		return -EINVAL;
+
+	serial[0] = serial_stringsize;
+	serial[1] = USB_DT_STRING;
+
+	/* convert to utf-16 */
+	printk("#Max index: %d\n", serial_stringsize - 1);
+	for (k = 0; k < count; ++k) {
+		printk("Address index %d and %d\n", 2+2*k, 2+2*k+1);
+		serial[2+2*k] = buf[k];
+		serial[2+2*k+1] = 0;
+	}
+
+	result = usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_SERIALNUMBER,
+		0, serial, serial_stringsize, 300);
+
+	if (result != serial_stringsize)
+		return -EIO;
+
+	return count;
+}
+
+static DEVICE_ATTR(serialnumber, S_IWUGO, NULL, write_serialnumber);
+
+
+static ssize_t write_productstring(struct device *dev,
+	struct device_attribute *attr,	const char *buf, size_t count)
+{
+	int result;
+	unsigned int k;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+	u8 product_stringsize = 2 + 2*count;
+	char product[2 + 2*PRODUCTSTRING_MAX_CHARS];
+
+	if (count > PRODUCTSTRING_MAX_CHARS)
+		return -EINVAL;
+
+	product[0] = product_stringsize;
+	product[1] = USB_DT_STRING;
+
+	/* convert to utf-16 */
+	for (k = 0; k < count; ++k) {
+		product[2+2*k] = buf[k];
+		product[2+2*k+1] = 0;
+	}
+
+	result = usb_control_msg(usbdev,
+			usb_sndctrlpipe(usbdev, 0),
+			CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE,
+			EEPROM_PRODUCTSTRING, 0,
+			product, product_stringsize, 300);
+
+	if (result != product_stringsize)
+		return -EIO;
+
+	return count;
+}
+
+static DEVICE_ATTR(productstring, S_IWUGO, NULL, write_productstring);
+
+static ssize_t write_self_powered(struct device *dev,
+	struct device_attribute *attr,	const char *buf, size_t count)
+{
+	int result;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long self_powered = strict_strtoul(buf, NULL, 0);
+
+	result = usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_POWER_ATTRIB,
+		self_powered ? 0x00c0 : 0x0080, NULL, 0, 300);
+
+	if (result)
+		return -EIO;
+
+	return count;
+}
+
+static DEVICE_ATTR(self_powered, S_IWUGO, NULL, write_self_powered);
+
+static ssize_t write_max_power(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t count)
+{
+	int result;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long max_power = strict_strtoul(buf, NULL, 0);
+
+	if (!max_power || max_power > 0xff)
+		return -EINVAL;
+
+	result = usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_MAX_POWER,
+		max_power, NULL, 0, 300);
+
+	if (result)
+		return -EIO;
+
+	return count;
+}
+
+static DEVICE_ATTR(max_power, S_IWUGO, NULL, write_max_power);
+
+static ssize_t write_release_version(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t count)
+{
+	int result;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long release_version = strict_strtoul(buf, NULL, 0);
+
+	if (release_version > 0xffff)
+		return -EINVAL;
+
+	result = usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_RELEASE_VERSION,
+		release_version, NULL, 0, 300);
+
+	if (result)
+		return -EIO;
+
+	return count;
+}
+
+static DEVICE_ATTR(release_version, S_IWUGO, NULL, write_release_version);
+
+static ssize_t write_lock_forever(struct device *dev,
+	struct device_attribute *attr,	const char *buf, size_t count)
+{
+	int result;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long lock = strict_strtoul(buf, NULL, 0);
+
+	/* be really, really sure to know what you are doing here */
+	if (lock != 0xabadbabe)
+		return -EINVAL;
+
+	result = usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_LOCK,
+		0x00f0, NULL, 0, 300);
+
+	if (result)
+		return -EIO;
+
+	return count;
+}
+
+static DEVICE_ATTR(lock_forever, S_IWUGO, NULL, write_lock_forever);
+
+static struct attribute *cp2101_attributes[] = {
+	&dev_attr_reload.attr,
+	&dev_attr_vendor_id.attr,
+	&dev_attr_product_id.attr,
+	&dev_attr_productstring.attr,
+	&dev_attr_serialnumber.attr,
+	&dev_attr_self_powered.attr,
+	&dev_attr_max_power.attr,
+	&dev_attr_release_version.attr,
+	&dev_attr_lock_forever.attr,
+	NULL
+};
+
+static const struct attribute_group cp2101_group = {
+	.attrs = cp2101_attributes,
+};
+
 static int cp2101_startup (struct usb_serial *serial)
 {
+	int err;
+
 	/* CP2101 buffers behave strangely unless device is reset */
 	usb_reset_device(serial->dev);
-	return 0;
+
+	if (!enable_config)
+		return 0;
+
+	err = sysfs_create_group(&serial->dev->dev.kobj, &cp2101_group);
+	
+	return err;
 }
 
 static void cp2101_shutdown (struct usb_serial *serial)
@@ -721,6 +1015,11 @@ static void cp2101_shutdown (struct usb_
 	for (i=0; i < serial->num_ports; ++i) {
 		cp2101_cleanup(serial->port[i]);
 	}
+
+	if (!enable_config)
+		return;
+
+	sysfs_remove_group(&serial->dev->dev.kobj, &cp2101_group);
 }
 
 static int __init cp2101_init (void)
@@ -758,3 +1057,6 @@ MODULE_LICENSE("GPL");
 
 module_param(debug, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Enable verbose debugging messages");
+
+module_param(enable_config, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(enable_config, "Enable sysfs access to configuration eeprom.");
#4 lore raw
Quoted 2 lines · On Fri, 29 Feb 2008 13:31:11 +0100 Dirk Eibach <[email protected]> wrote:

So here is a new try.

Please reissue the possibly-updated changelog and signed-off-by: with each revision of a patch.

Please cc linux-usb on usb patches.

Quoted 13 lines

diff -purN linux-2.6.24/drivers/usb/serial/cp2101.c linux-2.6.24-diff/drivers/usb/serial/cp2101.c

drivers/usb/serial/cp2101.c +2 -0
@@ -18,6 +18,8 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/platform_device.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/tty.h>

drivers/usb/serial/cp2101.c static void cp2101_shutdown(struct usb_s · line 57

Quoted 4 lines
drivers/usb/serial/cp2101.c +1 -0
@@ -52,6 +54,8 @@ static void cp2101_shutdown(struct usb_s
 
 static int debug;
 
+static int enable_config = false;

Should be either

static int enable_config;

or, if you're being very formal,

static bool enable_config = false;

or, if you're being less formal and want to avoid bloating the kernel image,

static bool enable_config;

Quoted 9 lines
drivers/usb/serial/cp2101.c +9 -0
+static ssize_t write_reload(struct device *dev, struct device_attribute *attr,
+	const char *buf, size_t count)
+{
+	int result;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	/* writing "0" does not trigger */
+	if (!strict_strtoul(buf, NULL, 0))
+		return count;

drivers/usb/serial/cp2101.c static void cp2101_break_ctl (struct usb · line 758

Quoted 10 lines
drivers/usb/serial/cp2101.c +10 -0
+
+	result = usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_RELOAD,
+		0, NULL, 0, 300);
+
+	/* this request is expected to fail because cp210x reboots */
+
+	return count;
+}

The comment will suffice - there's no need to add the do-nothing `result'.

Quoted 13 lines
drivers/usb/serial/cp2101.c +13 -0
+static DEVICE_ATTR(reload, S_IWUGO, NULL, write_reload);
+
+static ssize_t write_vendor_id(struct device *dev, struct device_attribute *attr,
+	const char *buf, size_t count)
+{
+	int result;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long vendor_id = strict_strtoul(buf, NULL, 0);
+
+	if (!vendor_id || vendor_id > 0xffff)
+		return -EINVAL;
+

drivers/usb/serial/cp2101.c static void cp2101_break_ctl (struct usb · line 782

Quoted 10 lines
drivers/usb/serial/cp2101.c +10 -0
+	result = usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_VENDOR_ID,
+		vendor_id, NULL, 0, 300);
+
+	if (result)
+		return -EIO;
+
+	return count;
+}

usb_control_msg() already returns an errno - we should just propagate that back to the caller rather than overwriting, say, -ENOMEM with -EIO.

Quoted 13 lines
drivers/usb/serial/cp2101.c +13 -0
+static DEVICE_ATTR(vendor_id, S_IWUGO, NULL, write_vendor_id);
+
+static ssize_t write_product_id(struct device *dev, struct device_attribute *attr,
+	const char *buf, size_t count)
+{
+	int result;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long product_id = strict_strtoul(buf, NULL, 0);
+
+	if (!product_id || product_id > 0xffff)
+		return -EINVAL;
+

drivers/usb/serial/cp2101.c static void cp2101_break_ctl (struct usb · line 806

Quoted 10 lines
drivers/usb/serial/cp2101.c +10 -0
+	result = usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_PRODUCT_ID,
+		product_id, NULL, 0, 300);
+
+	if (result)
+		return -EIO;
+
+	return count;
+}

ditto

drivers/usb/serial/cp2101.c static void cp2101_break_ctl (struct usb · line 817

Quoted 10 lines
drivers/usb/serial/cp2101.c +10 -0
+static DEVICE_ATTR(product_id, S_IWUGO, NULL, write_product_id);
+
+static ssize_t write_serialnumber(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t count)
+{
+	int result;
+	unsigned int k;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+	u8 serial_stringsize = 2 + 2*count;
+	char serial[2 + 2*SERIALNUMBER_MAX_CHARS];

128 bytes of stack is a little more than we'd like (the kernel is really squeezy on stack space sometimes). kmalloc would be better...

drivers/usb/serial/cp2101.c static void cp2101_break_ctl (struct usb · line 826

Quoted 8 lines
drivers/usb/serial/cp2101.c +8 -0
+	if (count > SERIALNUMBER_MAX_CHARS)
+		return -EINVAL;
+
+	serial[0] = serial_stringsize;
+	serial[1] = USB_DT_STRING;
+
+	/* convert to utf-16 */
+	printk("#Max index: %d\n", serial_stringsize - 1);

checkpatch...

Quoted 20 lines
drivers/usb/serial/cp2101.c +17 -0
+	for (k = 0; k < count; ++k) {
+		printk("Address index %d and %d\n", 2+2*k, 2+2*k+1);
+		serial[2+2*k] = buf[k];
+		serial[2+2*k+1] = 0;
+	}
+
+	result = usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_SERIALNUMBER,
+		0, serial, serial_stringsize, 300);
+
+	if (result != serial_stringsize)
+		return -EIO;
+
+	return count;
+}
 
...
 
+static ssize_t write_lock_forever(struct device *dev,

drivers/usb/serial/cp2101.c static void cp2101_break_ctl (struct usb · line 912

Quoted 10 lines
drivers/usb/serial/cp2101.c +10 -0
+	struct device_attribute *attr,	const char *buf, size_t count)
+{
+	int result;
+	struct usb_device *usbdev = container_of(dev, struct usb_device, dev);
+
+	unsigned long lock = strict_strtoul(buf, NULL, 0);
+
+	/* be really, really sure to know what you are doing here */
+	if (lock != 0xabadbabe)
+		return -EINVAL;

this is incomprehehsible without docs

Quoted 67 lines
drivers/usb/serial/cp2101.c +47 -1
+	result = usb_control_msg(usbdev,
+		usb_sndctrlpipe(usbdev, 0),
+		CP2101_EEPROM, REQTYPE_HOST_TO_DEVICE, EEPROM_LOCK,
+		0x00f0, NULL, 0, 300);
+
+	if (result)
+		return -EIO;
+
+	return count;
+}
+
+static DEVICE_ATTR(lock_forever, S_IWUGO, NULL, write_lock_forever);
+
+static struct attribute *cp2101_attributes[] = {
+	&dev_attr_reload.attr,
+	&dev_attr_vendor_id.attr,
+	&dev_attr_product_id.attr,
+	&dev_attr_productstring.attr,
+	&dev_attr_serialnumber.attr,
+	&dev_attr_self_powered.attr,
+	&dev_attr_max_power.attr,
+	&dev_attr_release_version.attr,
+	&dev_attr_lock_forever.attr,
+	NULL
+};
+
+static const struct attribute_group cp2101_group = {
+	.attrs = cp2101_attributes,
+};
+
 static int cp2101_startup (struct usb_serial *serial)
 {
+	int err;
+
 	/* CP2101 buffers behave strangely unless device is reset */
 	usb_reset_device(serial->dev);
-	return 0;
+
+	if (!enable_config)
+		return 0;
+
+	err = sysfs_create_group(&serial->dev->dev.kobj, &cp2101_group);
+	
+	return err;
 }
 
 static void cp2101_shutdown (struct usb_serial *serial)
@@ -721,6 +1015,11 @@ static void cp2101_shutdown (struct usb_
 	for (i=0; i < serial->num_ports; ++i) {
 		cp2101_cleanup(serial->port[i]);
 	}
+
+	if (!enable_config)
+		return;
+
+	sysfs_remove_group(&serial->dev->dev.kobj, &cp2101_group);
 }
 
 static int __init cp2101_init (void)
@@ -758,3 +1057,6 @@ MODULE_LICENSE("GPL");
 
 module_param(debug, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Enable verbose debugging messages");
+
+module_param(enable_config, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(enable_config, "Enable sysfs access to configuration eeprom.");
#5 lore raw

From: Dirk Eibach <[email protected]>

The usb configuration data for the Silabs CP2101 usb to uart bridge controller can be customized:
- Vendor ID
- Product ID
- Power Descriptor
- Release Number
- Serial Number
- Product Description String

Silabs provides a windows-only tool to do that.
Since we use linux-only machines in our production-environment, we have no proper way to customize the chips for our purpose.
So I added sysfs configuration support to the linux driver.

---

Documentation/ABI/testing/sysfs-bus-usb-devices-cp2101 +44 -0
diff -purN linux-2.6.24/Documentation/ABI/testing/sysfs-bus-usb-devices-cp2101 linux-2.6.24-diff/Documentation/ABI/testing/sysfs-bus-usb-devices-cp2101
@@ -0,0 +1,44 @@
+What:		cp2101 sysfs device customization-interface
+Date:		03.03.2008
+KernelVersion:	2.6.26
+Contact:	Dirk Eibach <[email protected]>
+Description:	
+
+The usb configuration data for the Silabs CP2101 usb to uart bridge 
+controller are stored in an on-chip eeprom and can be customized:
+- Vendor ID
+- Product ID
+- Power Descriptor
+- Release Number
+- Serial Number
+- Product Description String
+
+When loaded with module parameter "enable_config=1" the cp2101 driver offers 
+the following sysfs attributes to customize USB configuration data:
+
+reload
+	write "1" to reboot CP210x and activate the new configuration
+
+vendor_id
+	write 16 bit value to set
+
+product_id
+	write 16 bit value to set
+
+productstring
+	write up to 126 characters to set
+
+serialnumber
+	write up to 63 characters to set
+
+self_powered
+	write "1" to set, "0" to unset
+
+max_power
+	write 8 bit value (unit 2 mA) to set
+
+release_version
+	write 16 bit BCD-value to set (0x1234 => version 12.34)
+
+lock_forever
+	write "1" to lock the settings permanently (*no way back*)
drivers/usb/serial/cp2101.c +326 -1

370 lines not on this page · raw message

#6 lore raw
Quoted 11 lines · Dirk Eibach

From: Dirk Eibach <[email protected]>

The usb configuration data for the Silabs CP2101 usb to uart bridge controller can be customized:
- Vendor ID
- Product ID
- Power Descriptor
- Release Number
- Serial Number
- Product Description String

Quoted 4 lines

Silabs provides a windows-only tool to do that.
Since we use linux-only machines in our production-environment, we have no proper way to customize the chips for our purpose.
So I added sysfs configuration support to the linux driver.

Surely this sort of thing is better done in userspace, with libusb.

Alan Stern

#7 lore raw
Quoted 13 lines · Alan Stern
Quoted 11 lines · Dirk Eibach

From: Dirk Eibach <[email protected]>

The usb configuration data for the Silabs CP2101 usb to uart bridge controller can be customized:
- Vendor ID
- Product ID
- Power Descriptor
- Release Number
- Serial Number
- Product Description String

Quoted 6 lines
Quoted 4 lines

Silabs provides a windows-only tool to do that.
Since we use linux-only machines in our production-environment, we have no proper way to customize the chips for our purpose.
So I added sysfs configuration support to the linux driver.

Surely this sort of thing is better done in userspace, with libusb.

I agree, any reason why you have not tried that? Adding files like "vendor_id" to an interface directory in sysfs could cause a lot of people to get very confused, very quickly :)

thanks,

greg k-h

#8 lore raw
Quoted 18 lines · [email protected] wrote:
Quoted 17 lines · Alan Stern
Quoted 15 lines · Dirk Eibach

From: Dirk Eibach <[email protected]>

The usb configuration data for the Silabs CP2101 usb to uart bridge controller can be customized:
- Vendor ID
- Product ID
- Power Descriptor
- Release Number
- Serial Number
- Product Description String

Silabs provides a windows-only tool to do that.
Since we use linux-only machines in our production-environment, we have no proper way to customize the chips for our purpose.
So I added sysfs configuration support to the linux driver.

Quoted 5 lines
Quoted 1 line

Surely this sort of thing is better done in userspace, with libusb.

I agree, any reason why you have not tried that? Adding files like "vendor_id" to an interface directory in sysfs could cause a lot of people to get very confused, very quickly :)

Greg, any reason why you didn't suggest using libusb in your first mail ;) ?

I have not used libusb yet, but looking at the api it seems to be just what I need. I had heard about libusb before, but never really had a look at it. So thanks for your advice, Alan. I will implement this stuff in userspace.

On the other hand it would a little bit sad, if Silabs windows tool would stay the only way to setup for all other people. I cannot see how I could spread the userspace tool the way it would be spread if it was in the kernel. Maybe someone has an idea on that.

So, sorry for the noise guys.

Cheers
Dirk

#9 lore raw
Quoted 4 lines · Dirk Eibach

On the other hand it would a little bit sad, if Silabs windows tool would stay the only way to setup for all other people. I cannot see how I could spread the userspace tool the way it would be spread if it was in the kernel. Maybe someone has an idea on that.

Maybe you shouldn't try to spread your userspace tool as widely as the kernel. After all, most kernel users don't have a CP2101.

If you put the tool on a web site, people who need it will be able to find it using Google.

Alan Stern

#10 lore raw
In reply to Dirk Eibach
Quoted 19 lines · Dirk Eibach
Quoted 18 lines · [email protected] wrote:
Quoted 17 lines · Alan Stern
Quoted 15 lines · Dirk Eibach

From: Dirk Eibach <[email protected]>

The usb configuration data for the Silabs CP2101 usb to uart bridge controller can be customized:
- Vendor ID
- Product ID
- Power Descriptor
- Release Number
- Serial Number
- Product Description String

Silabs provides a windows-only tool to do that.
Since we use linux-only machines in our production-environment, we have no proper way to customize the chips for our purpose.
So I added sysfs configuration support to the linux driver.

Quoted 7 lines
Quoted 5 lines
Quoted 1 line

Surely this sort of thing is better done in userspace, with libusb.

I agree, any reason why you have not tried that? Adding files like "vendor_id" to an interface directory in sysfs could cause a lot of people to get very confused, very quickly :)

Greg, any reason why you didn't suggest using libusb in your first mail ;) ?

My appologies, I totally forgot about it at the moment. It's usually my first question when confronted with a new driver, not a patch to an existing one.

Quoted 9 lines

I have not used libusb yet, but looking at the api it seems to be just what I need. I had heard about libusb before, but never really had a look at it. So thanks for your advice, Alan. I will implement this stuff in userspace.

On the other hand it would a little bit sad, if Silabs windows tool would stay the only way to setup for all other people. I cannot see how I could spread the userspace tool the way it would be spread if it was in the kernel. Maybe someone has an idea on that.

Just get it added to all of the distros, that shouldn't be that hard, I think almost all of them let you request a package to be added.

thanks,

greg k-h

#11 lore raw
In reply to Andrew Morton
Quoted 6 lines · Andrew Morton
Quoted 1 line

+static int enable_config = false;

Should be either

static int enable_config;

Quoted 7 lines

or, if you're being very formal,

static bool enable_config = false;

or, if you're being less formal and want to avoid bloating the kernel image,

static bool enable_config;

I've added detection of false as a 0 value in external and static contexts; this should be reported in the 0.18:

ERROR: do not initialise statics to 0 or NULL
#1: FILE: Z118.c:1:
+static bool enable_config = false;

-apw

#12 lore raw
In reply to Dirk Eibach
Quoted 1 line · Dirk Eibach

So here is a new try.

Please provide a full changelog entry, and signed-off-by: if you wish to have it applied to the tree.

As you are adding new sysfs entries, I need some documentation to be added in Documentation/ABI/ describing these new files and how they are to be used. See the instructions there for the format needed.

Quoted 53 lines

---
diff -purN linux-2.6.24/drivers/usb/serial/cp2101.c linux-2.6.24-diff/drivers/usb/serial/cp2101.c

drivers/usb/serial/cp2101.c +19 -0
@@ -18,6 +18,8 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/platform_device.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/tty.h>
@@ -52,6 +54,8 @@ static void cp2101_shutdown(struct usb_s
 
 static int debug;
 
+static int enable_config = false;
+
 static struct usb_device_id id_table [] = {
 	{ USB_DEVICE(0x08e6, 0x5501) }, /* Gemalto Prox-PU/CU contactless smartcard reader */
 	{ USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */
@@ -125,6 +129,7 @@ static struct usb_serial_driver cp2101_d
 #define CP2101_CONTROL		0x07	/* Flow control line states */
 #define CP2101_MODEMCTL		0x13	/* Modem controls */
 #define CP2101_CONFIG_6		0x19	/* 6 bytes of config data ??? */
+#define CP2101_EEPROM		0xFF	/* write configuration eeprom */
 
 /* CP2101_UART */
 #define UART_ENABLE		0x0001
@@ -167,6 +172,20 @@ static struct usb_serial_driver cp2101_d
 #define CONTROL_WRITE_DTR	0x0100
 #define CONTROL_WRITE_RTS	0x0200
 
+/* CP2101 CONFIGURATION EEPROM */
+#define EEPROM_RELOAD		0x0008
+#define EEPROM_VENDOR_ID	0x3701
+#define EEPROM_PRODUCT_ID	0x3702
+#define EEPROM_PRODUCTSTRING	0x3703
+#define EEPROM_SERIALNUMBER	0x3704
+#define EEPROM_POWER_ATTRIB	0x3705
+#define EEPROM_MAX_POWER	0x3706
+#define EEPROM_RELEASE_VERSION	0x3707
+#define EEPROM_LOCK		0x370a
+
+#define SERIALNUMBER_MAX_CHARS	63
+#define PRODUCTSTRING_MAX_CHARS	126
+
 /*
  * cp2101_get_config
  * Reads from the CP2101 configuration registers

drivers/usb/serial/cp2101.c static void cp2101_break_ctl (struct usb · line 731

Quoted 9 lines
drivers/usb/serial/cp2101.c +6 -0
@@ -704,11 +723,286 @@ static void cp2101_break_ctl (struct usb
 	cp2101_set_config(port, CP2101_BREAK, &state, 2);
 }
 
+/*
+ * When loaded with module parameter "enable_config=1" the driver offers the
+ * following sysfs attributes to customize USB configuration data:
+ * reload: write "1" to reboot CP210x and activate the new configuration
+ * vendor_id: write 16 bit value to set
+ * product_id: write 16 bit value to set

This seems odd, you know we already allow any usb vendor and product id to be automatically added to a driver after it has been loaded through sysfs, right? Wouldn't that take care of the majority of the issues you have here?

Oh, wait, this is setting the device itself, nevermind.

You should use configfs for this instead, that's what it is for moreso than sysfs, right?

thanks,

greg k-h

#13 lore raw
In reply to Andrew Morton
Quoted 7 lines · Andrew Morton

On Fri, 29 Feb 2008 10:02:18 +0100 Dirk Eibach <[email protected]> wrote:

We have a new strict_strtoul() (and related functions) which will perform proper checking for a valid number. Please use that interface.

Andy, this is going to happen so much that a "should you have used strict_strtoul?" warning in checkpatch would reduce my email output.

Sure, will add something. I wonder if this new interface is documented.

I note that this interface is new in -mm at this time. So that brings up an interesting question as to how one would integrate this check with checkpatch. As checking patches for mainline, this would be an incorrect check until that patch merges. I guess the right thing to do is provide a separate patch for checkpatch which adds this check which should sit with the patch in your tree which adds the functionality.

Make sense?

-apw

#14 lore raw
Quoted 10 lines · On Fri, 29 Feb 2008 14:44:37 +0000 Andy Whitcroft <[email protected]> wrote:
Quoted 7 lines · Andrew Morton

On Fri, 29 Feb 2008 10:02:18 +0100 Dirk Eibach <[email protected]> wrote:

We have a new strict_strtoul() (and related functions) which will perform proper checking for a valid number. Please use that interface.

Andy, this is going to happen so much that a "should you have used strict_strtoul?" warning in checkpatch would reduce my email output.

Sure, will add something. I wonder if this new interface is documented.

It has kerneldoc.

Quoted 1 line

I note that this interface is new in -mm at this time.

It is in mainline.

Quoted 7 lines

So that brings
up an interesting question as to how one would integrate this check with checkpatch. As checking patches for mainline, this would be an incorrect check until that patch merges. I guess the right thing to do is provide a separate patch for checkpatch which adds this check which should sit with the patch in your tree which adds the functionality.

It would be easier to just update your kernel tree ;)