linux: added 2.6.35.14 kernel

Changes from 2.6.32.3 CDP kernel
--------------------------------
* upgraded sierra driver to 1.7.40
* dropped option.c patch - changes merged upstream by James Maki
* dropped at91_mci patch - changes merged upstream
* dropped m25p80 patch - changes merged upgrstream

9 files changed, 5200 insertions, 0 deletions

diff --git a/multitech/recipes/linux/linux-2.6.35/linux-2.6.32.3-at25.patch b/multitech/recipes/linux/linux-2.6.35/linux-2.6.32.3-at25.patch
new file mode 100644
index 0000000..3aa9096
--- /dev/null
+++ b/multitech/recipes/linux/linux-2.6.35/linux-2.6.32.3-at25.patch
@@ -0,0 +1,37 @@
+diff -uprN -X linux-2.6.32.3/Documentation/dontdiff linux-2.6.32.3-vanilla/drivers/misc/eeprom/at25.c linux-2.6.32.3/drivers/misc/eeprom/at25.c
+--- linux-2.6.32.3-vanilla/drivers/misc/eeprom/at25.c	2010-01-06 17:07:45.000000000 -0600
++++ linux-2.6.32.3/drivers/misc/eeprom/at25.c	2010-10-27 11:05:36.000000000 -0500
+@@ -147,6 +147,7 @@ at25_ee_write(struct at25_data *at25, co
+ 	unsigned		written = 0;
+ 	unsigned		buf_size;
+ 	u8			*bounce;
++	int			a8;
+ 
+ 	if (unlikely(off >= at25->bin.size))
+ 		return -EFBIG;
+@@ -163,6 +164,11 @@ at25_ee_write(struct at25_data *at25, co
+ 	if (!bounce)
+ 		return -ENOMEM;
+ 
++	if (!strcmp(at25->chip.name, "at25040b"))
++		a8 = 1;
++	else
++		a8 = 0;
++
+ 	/* For write, rollover is within the page ... so we write at
+ 	 * most one page, then manually roll over to the next page.
+ 	 */
+@@ -183,6 +189,13 @@ at25_ee_write(struct at25_data *at25, co
+ 			break;
+ 		}
+ 
++		if (a8) {
++			if (offset & BIT(8))
++				bounce[0] |= BIT(3);
++			else
++				bounce[0] &= ~BIT(3);
++		}
++
+ 		/* 8/16/24-bit address is written MSB first */
+ 		switch (at25->addrlen) {
+ 		default:	/* case 3 */
diff --git a/multitech/recipes/linux/linux-2.6.35/linux-2.6.32.3-atmel_serial_disable_hwhs.patch b/multitech/recipes/linux/linux-2.6.35/linux-2.6.32.3-atmel_serial_disable_hwhs.patch
new file mode 100644
index 0000000..bd620af
--- /dev/null
+++ b/multitech/recipes/linux/linux-2.6.35/linux-2.6.32.3-atmel_serial_disable_hwhs.patch
@@ -0,0 +1,32 @@
+Revert commit 8e706c4d0dab214c625a2df84a0ca69a76bae65d in linux-2.6:
+  avr32: add hardware handshake support to atmel_serial
+
+Reverting commit since it breaks hardware flow control for at91sam9g20
+
+diff --git a/drivers/serial/atmel_serial.c b/drivers/serial/atmel_serial.c
+index 9d948bc..b659f2c 100644
+--- a/drivers/serial/atmel_serial.c
++++ b/drivers/serial/atmel_serial.c
+@@ -1020,8 +1020,7 @@ static void atmel_set_termios(struct uart_port *port, struct ktermios *termios,
+ 
+ 	/* Get current mode register */
+ 	mode = UART_GET_MR(port) & ~(ATMEL_US_USCLKS | ATMEL_US_CHRL
+-					| ATMEL_US_NBSTOP | ATMEL_US_PAR
+-					| ATMEL_US_USMODE);
++					| ATMEL_US_NBSTOP | ATMEL_US_PAR);
+ 
+ 	baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk / 16);
+ 	quot = uart_get_divisor(port, baud);
+@@ -1066,12 +1065,6 @@ static void atmel_set_termios(struct uart_port *port, struct ktermios *termios,
+ 	} else
+ 		mode |= ATMEL_US_PAR_NONE;
+ 
+-	/* hardware handshake (RTS/CTS) */
+-	if (termios->c_cflag & CRTSCTS)
+-		mode |= ATMEL_US_USMODE_HWHS;
+-	else
+-		mode |= ATMEL_US_USMODE_NORMAL;
+-
+ 	spin_lock_irqsave(&port->lock, flags);
+ 
+ 	port->read_status_mask = ATMEL_US_OVRE;
diff --git a/multitech/recipes/linux/linux-2.6.35/linux-2.6.32.3-atmel_spi.patch b/multitech/recipes/linux/linux-2.6.35/linux-2.6.32.3-atmel_spi.patch
new file mode 100644
index 0000000..a7b87b3
--- /dev/null
+++ b/multitech/recipes/linux/linux-2.6.35/linux-2.6.32.3-atmel_spi.patch
@@ -0,0 +1,12 @@
+diff -uprN -X linux-2.6.32.3/Documentation/dontdiff linux-2.6.32.3-vanilla/drivers/spi/atmel_spi.c linux-2.6.32.3/drivers/spi/atmel_spi.c
+--- linux-2.6.32.3-vanilla/drivers/spi/atmel_spi.c	2010-01-06 17:07:45.000000000 -0600
++++ linux-2.6.32.3/drivers/spi/atmel_spi.c	2010-09-08 13:38:52.000000000 -0500
+@@ -768,7 +768,7 @@ static int __init atmel_spi_probe(struct
+ 	master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
+ 
+ 	master->bus_num = pdev->id;
+-	master->num_chipselect = 4;
++	master->num_chipselect = 7;
+ 	master->setup = atmel_spi_setup;
+ 	master->transfer = atmel_spi_transfer;
+ 	master->cleanup = atmel_spi_cleanup;
diff --git a/multitech/recipes/linux/linux-2.6.35/linux-2.6.35-sierra-1.7.40.patch b/multitech/recipes/linux/linux-2.6.35/linux-2.6.35-sierra-1.7.40.patch
new file mode 100644
index 0000000..195a62c
--- /dev/null
+++ b/multitech/recipes/linux/linux-2.6.35/linux-2.6.35-sierra-1.7.40.patch
@@ -0,0 +1,1071 @@
+Index: linux-2.6.35/drivers/usb/serial/sierra.c
+===================================================================
+--- linux-2.6.35.orig/drivers/usb/serial/sierra.c
++++ linux-2.6.35/drivers/usb/serial/sierra.c
+@@ -3,7 +3,7 @@
+ 
+   Copyright (C) 2006, 2007, 2008  Kevin Lloyd <klloyd@sierrawireless.com>,
+ 
+-  Copyright (C) 2008, 2009  Elina Pasheva, Matthew Safar, Rory Filer
++  Copyright (C) 2008 - 2011  Elina Pasheva, Matthew Safar, Rory Filer
+ 			<linux@sierrawireless.com>
+ 
+   IMPORTANT DISCLAIMER: This driver is not commercially supported by
+@@ -17,8 +17,12 @@
+   Whom based his on the Keyspan driver by Hugh Blemings <hugh@blemings.org>
+ */
+ /* Uncomment to log function calls */
+-/* #define DEBUG */
+-#define DRIVER_VERSION "v.1.7.16"
++/*#define DEBUG*/
++/* Uncomment to force power level set to auto when attaching a device */
++/*#define POWER_LEVEL_AUTO*/
++
++/* Sierra driver - kernel 2.6.35 */
++#define DRIVER_VERSION "v.1.7.40"
+ #define DRIVER_AUTHOR "Kevin Lloyd, Elina Pasheva, Matthew Safar, Rory Filer"
+ #define DRIVER_DESC "USB Driver for Sierra Wireless USB modems"
+ 
+@@ -31,9 +35,13 @@
+ #include <linux/module.h>
+ #include <linux/usb.h>
+ #include <linux/usb/serial.h>
++#include <asm/unaligned.h>
+ 
+ #define SWIMS_USB_REQUEST_SetPower	0x00
++#define SWIMS_USB_REQUEST_GetFwAttr	0x06
+ #define SWIMS_USB_REQUEST_SetNmea	0x07
++#define USB_REQUEST_TYPE_CLASS		0xA1
++#define USB_REQUEST_IFACE		0x20
+ 
+ #define N_IN_URB_HM	8
+ #define N_OUT_URB_HM	64
+@@ -46,19 +54,47 @@
+    allocations > PAGE_SIZE and the number of packets in a page
+    is an integer 512 is the largest possible packet on EHCI */
+ 
++#define SWI_FW_ATTR_PM_MASK		0x02
++/* PORTION_LEN defines the length of device attribute buffer */
++#define PORTION_LEN			4096
++
+ static int debug;
+ static int nmea;
+ 
++/* sysfs attributes */
++static int sierra_create_sysfs_attrs(struct usb_serial_port *port);
++static int sierra_remove_sysfs_attrs(struct usb_serial_port *port);
++
+ /* Used in interface blacklisting */
+ struct sierra_iface_info {
+ 	const u32 infolen;	/* number of interface numbers on blacklist */
+ 	const u8  *ifaceinfo;	/* pointer to the array holding the numbers */
+ };
+ 
++/* per interface statistics */
++struct sierra_intf_stats {
++	atomic_t	rx_bytes;		/* received bytes */
++	atomic_t	indat_cb_cnt;		/* indat callback count */
++	atomic_t	indat_cb_fail;		/* indat cb with error */
++
++	atomic_t	tx_bytes;		/* transmitted bytes */
++	atomic_t	write_cnt;		/* no. of writes */
++	atomic_t	write_err;		/* no. of failed writes */
++
++	atomic_t	delayed_writes;		/* no. of delayed writes */
++	atomic_t	delayed_write_err;	/* no. of delayed write errs */
++
++	atomic_t	outdat_cb_cnt;		/* outdat callback count */
++	atomic_t	outdat_cb_fail;		/* outdat cb with error */
++
++};
++
+ struct sierra_intf_private {
+ 	spinlock_t susp_lock;
+ 	unsigned int suspended:1;
+ 	int in_flight;
++
++	struct sierra_intf_stats stats;
+ };
+ 
+ static int sierra_set_power_state(struct usb_device *udev, __u16 swiState)
+@@ -91,6 +127,38 @@ static int sierra_vsc_set_nmea(struct us
+ 	return result;
+ }
+ 
++static int sierra_get_fw_attr(struct usb_device *udev, u16 *data)
++{
++	int result;
++	u16 *attrdata;
++
++	dev_dbg(&udev->dev, "%s\n", __func__);
++
++	attrdata = kmalloc(sizeof(*attrdata), GFP_KERNEL);
++	if (!attrdata)
++		return -ENOMEM;
++
++	result = usb_control_msg(udev,
++				usb_rcvctrlpipe(udev, 0),
++				SWIMS_USB_REQUEST_GetFwAttr,  /* __u8 request*/
++				USB_TYPE_VENDOR | USB_DIR_IN, /* request type*/
++				0x0000,			/* __u16 value       */
++				0x0000,			/* __u16 index       */
++				attrdata,		/* void *data        */
++				sizeof(*attrdata),	/* _u16 size         */
++				USB_CTRL_SET_TIMEOUT);	/* in timeout        */
++
++	if (result < 0) {
++		kfree(attrdata);
++		return -EIO;
++	}
++
++	*data = *attrdata;
++
++	kfree(attrdata);
++	return result;
++}
++
+ static int sierra_calc_num_ports(struct usb_serial *serial)
+ {
+ 	int num_ports = 0;
+@@ -150,7 +218,6 @@ static int sierra_calc_interface(struct 
+ 	int interface;
+ 	struct usb_interface *p_interface;
+ 	struct usb_host_interface *p_host_interface;
+-	dev_dbg(&serial->dev->dev, "%s\n", __func__);
+ 
+ 	/* Get the interface structure pointer from the serial struct */
+ 	p_interface = serial->interface;
+@@ -159,8 +226,7 @@ static int sierra_calc_interface(struct 
+ 	p_host_interface = p_interface->cur_altsetting;
+ 
+ 	/* read the interface descriptor for this active altsetting
+-	 * to find out the interface number we are on
+-	*/
++	 * to find out the interface number we are on */
+ 	interface = p_host_interface->desc.bInterfaceNumber;
+ 
+ 	return interface;
+@@ -171,7 +237,7 @@ static int sierra_probe(struct usb_seria
+ {
+ 	int result = 0;
+ 	struct usb_device *udev;
+-	struct sierra_intf_private *data;
++	struct sierra_intf_private *intfdata;
+ 	u8 ifnum;
+ 
+ 	udev = serial->dev;
+@@ -185,7 +251,9 @@ static int sierra_probe(struct usb_seria
+ 	if (serial->interface->num_altsetting == 2) {
+ 		dev_dbg(&udev->dev, "Selecting alt setting for interface %d\n",
+ 			ifnum);
+-		/* We know the alternate setting is 1 for the MC8785 */
++		/* We know the alternate setting is for composite USB interface
++		 * modems
++		 */
+ 		usb_set_interface(udev, ifnum, 1);
+ 	}
+ 
+@@ -199,10 +267,11 @@ static int sierra_probe(struct usb_seria
+ 		return -ENODEV;
+ 	}
+ 
+-	data = serial->private = kzalloc(sizeof(struct sierra_intf_private), GFP_KERNEL);
+-	if (!data)
++	intfdata = serial->private = kzalloc(sizeof(struct sierra_intf_private),
++						GFP_KERNEL);
++	if (!intfdata)
+ 		return -ENOMEM;
+-	spin_lock_init(&data->susp_lock);
++	spin_lock_init(&intfdata->susp_lock);
+ 
+ 	return result;
+ }
+@@ -223,15 +292,15 @@ static const struct sierra_iface_info ty
+ /* 'blacklist' of interfaces not served by this driver */
+ static const u8 direct_ip_non_serial_ifaces[] = { 7, 8, 9, 10, 11 };
+ static const struct sierra_iface_info direct_ip_interface_blacklist = {
+-	.infolen = ARRAY_SIZE(direct_ip_non_serial_ifaces),
++	.infolen = ARRAY_SIZE( direct_ip_non_serial_ifaces ),
+ 	.ifaceinfo = direct_ip_non_serial_ifaces,
+ };
+ 
+-static const struct usb_device_id id_table[] = {
++static const struct usb_device_id id_table [] = {
+ 	{ USB_DEVICE(0x0F3D, 0x0112) }, /* Airprime/Sierra PC 5220 */
+ 	{ USB_DEVICE(0x03F0, 0x1B1D) },	/* HP ev2200 a.k.a MC5720 */
+-	{ USB_DEVICE(0x03F0, 0x211D) }, /* HP ev2210 a.k.a MC5725 */
+ 	{ USB_DEVICE(0x03F0, 0x1E1D) },	/* HP hs2300 a.k.a MC8775 */
++	{ USB_DEVICE(0x03F0, 0x211D) }, /* HP ev2210 a.k.a MC5725 */
+ 
+ 	{ USB_DEVICE(0x1199, 0x0017) },	/* Sierra Wireless EM5625 */
+ 	{ USB_DEVICE(0x1199, 0x0018) },	/* Sierra Wireless MC5720 */
+@@ -245,7 +314,10 @@ static const struct usb_device_id id_tab
+ 	{ USB_DEVICE(0x1199, 0x0021) },	/* Sierra Wireless AirCard 597E */
+ 	{ USB_DEVICE(0x1199, 0x0112) }, /* Sierra Wireless AirCard 580 */
+ 	{ USB_DEVICE(0x1199, 0x0120) },	/* Sierra Wireless USB Dongle 595U */
+-	{ USB_DEVICE(0x1199, 0x0301) },	/* Sierra Wireless USB Dongle 250U */
++	{ USB_DEVICE(0x1199, 0x0301) },	/* Sierra Wireless USB Dongle 250U/3G */
++	/* Sierra Wireless MC5728 */
++	{ USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x0400, 0xFF, 0xFF, 0xFF) },
++
+ 	/* Sierra Wireless C597 */
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x0023, 0xFF, 0xFF, 0xFF) },
+ 	/* Sierra Wireless T598 */
+@@ -253,7 +325,7 @@ static const struct usb_device_id id_tab
+ 	{ USB_DEVICE(0x1199, 0x0026) }, /* Sierra Wireless T11 */
+ 	{ USB_DEVICE(0x1199, 0x0027) }, /* Sierra Wireless AC402 */
+ 	{ USB_DEVICE(0x1199, 0x0028) }, /* Sierra Wireless MC5728 */
+-	{ USB_DEVICE(0x1199, 0x0029) }, /* Sierra Wireless Device */
++	{ USB_DEVICE(0x114F, 0x6000) }, /* Sierra Wireless Q26 Elite */
+ 
+ 	{ USB_DEVICE(0x1199, 0x6802) },	/* Sierra Wireless MC8755 */
+ 	{ USB_DEVICE(0x1199, 0x6803) },	/* Sierra Wireless MC8765 */
+@@ -277,7 +349,7 @@ static const struct usb_device_id id_tab
+ 	{ USB_DEVICE(0x1199, 0x683A) },	/* Sierra Wireless MC8785 */
+ 	{ USB_DEVICE(0x1199, 0x683B) },	/* Sierra Wireless MC8785 Composite */
+ 	/* Sierra Wireless MC8790, MC8791, MC8792 Composite */
+-	{ USB_DEVICE(0x1199, 0x683C) },
++	{ USB_DEVICE(0x1199, 0x683C) },	
+ 	{ USB_DEVICE(0x1199, 0x683D) },	/* Sierra Wireless MC8791 Composite */
+ 	/* Sierra Wireless MC8790, MC8791, MC8792 */
+ 	{ USB_DEVICE(0x1199, 0x683E) },
+@@ -298,21 +370,34 @@ static const struct usb_device_id id_tab
+ 	/* Sierra Wireless HSPA Non-Composite Device */
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6892, 0xFF, 0xFF, 0xFF)},
+ 	{ USB_DEVICE(0x1199, 0x6893) },	/* Sierra Wireless Device */
+-	{ USB_DEVICE(0x1199, 0x68A3), 	/* Sierra Wireless Direct IP modems */
+-	  .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
++	/* Sierra Wireless Direct IP modems */
++	{ USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x68A3, 0xFF, 0xFF, 0xFF),
++	  .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist 
++	},
++	/* AT&T Direct IP modems */
++	{ USB_DEVICE_AND_INTERFACE_INFO(0x0F3D, 0x68A3, 0xFF, 0xFF, 0xFF),
++	  .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist 
++	},
++	/* Sierra Wireless Direct IP LTE modems */
++	{ USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x68AA, 0xFF, 0xFF, 0xFF),
++	  .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist 
+ 	},
+-       { USB_DEVICE(0x413C, 0x08133) }, /* Dell Computer Corp. Wireless 5720 VZW Mobile Broadband (EVDO Rev-A) Minicard GPS Port */
+-	{ USB_DEVICE(0x0f3d, 0x68A3), 	/* Airprime/Sierra Wireless Direct IP modems */
+-	  .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
++	/* AT&T Direct IP LTE modems */
++	{ USB_DEVICE_AND_INTERFACE_INFO(0x0F3D, 0x68AA, 0xFF, 0xFF, 0xFF),
++	  .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist 
+ 	},
++	/* Wireless 5720 VZW Mobile Broadband (EVDO Rev-A) Minicard GPS Port */
++	{ USB_DEVICE(0x413C, 0x8133) },
++
+ 	{ }
+ };
+ MODULE_DEVICE_TABLE(usb, id_table);
+ 
+-
++/* per port private data */
+ struct sierra_port_private {
+ 	spinlock_t lock;	/* lock the structure */
+ 	int outstanding_urbs;	/* number of out urbs in flight */
++
+ 	struct usb_anchor active;
+ 	struct usb_anchor delayed;
+ 
+@@ -334,7 +419,7 @@ struct sierra_port_private {
+ static int sierra_send_setup(struct usb_serial_port *port)
+ {
+ 	struct usb_serial *serial = port->serial;
+-	struct sierra_port_private *portdata;
++	struct sierra_port_private *portdata = usb_get_serial_port_data(port);
+ 	__u16 interface = 0;
+ 	int val = 0;
+ 	int do_send = 0;
+@@ -342,8 +427,6 @@ static int sierra_send_setup(struct usb_
+ 
+ 	dev_dbg(&port->dev, "%s\n", __func__);
+ 
+-	portdata = usb_get_serial_port_data(port);
+-
+ 	if (portdata->dtr_state)
+ 		val |= 0x01;
+ 	if (portdata->rts_state)
+@@ -436,11 +519,77 @@ static void sierra_release_urb(struct ur
+ 	if (urb) {
+ 		port =  urb->context;
+ 		dev_dbg(&port->dev, "%s: %p\n", __func__, urb);
+-		kfree(urb->transfer_buffer);
+ 		usb_free_urb(urb);
+ 	}
+ }
+ 
++/* Sysfs Attributes */
++
++static ssize_t show_suspend_status(struct device *dev,
++	struct device_attribute *attr, char *buf)
++{
++	struct usb_serial_port *port;
++	struct sierra_port_private *portdata;
++	struct sierra_intf_private *intfdata;
++	unsigned long flags;
++	unsigned int flag_suspended = 0;
++
++	port = to_usb_serial_port(dev);
++	portdata = usb_get_serial_port_data(port);
++	intfdata = port->serial->private;
++
++	spin_lock_irqsave(&intfdata->susp_lock, flags);
++	flag_suspended = intfdata->suspended;
++	spin_unlock_irqrestore(&intfdata->susp_lock, flags);
++
++	return snprintf(buf, PORTION_LEN, "%i\n", flag_suspended);
++}
++
++static ssize_t show_stats(struct device *dev,
++	struct device_attribute *attr, char *buf)
++{
++	struct usb_serial_port *port;
++	struct sierra_intf_private *intfdata;
++
++	port = to_usb_serial_port(dev);
++	intfdata = port->serial->private;
++
++	return snprintf(buf, PORTION_LEN,
++		"rx: %i B\tindat: %i\tindat err: %i\n"
++		"tx: %i B\toutdat: %i\toutdat err: %i\n"
++		"writes: %i\t\twrite err: %i\n"
++		"delayed writes: %i\tdelayed write err: %i\n",
++		atomic_read(&intfdata->stats.rx_bytes),	atomic_read(&intfdata->stats.indat_cb_cnt), atomic_read(&intfdata->stats.indat_cb_fail),
++		atomic_read(&intfdata->stats.tx_bytes), atomic_read(&intfdata->stats.outdat_cb_cnt), atomic_read(&intfdata->stats.outdat_cb_fail),
++		atomic_read(&intfdata->stats.write_cnt), atomic_read(&intfdata->stats.write_err),
++		atomic_read(&intfdata->stats.delayed_writes), atomic_read(&intfdata->stats.delayed_write_err)
++	);
++}
++
++/* Read only suspend status */
++static DEVICE_ATTR(suspend_status, S_IWUSR | S_IRUGO, show_suspend_status,
++							NULL);
++
++/* Read only statistics */
++static DEVICE_ATTR(stats, S_IWUSR | S_IRUGO, show_stats, NULL);
++
++static int sierra_create_sysfs_attrs(struct usb_serial_port *port)
++{
++	int result = 0;
++
++	result = device_create_file(&port->dev, &dev_attr_stats);
++	if (unlikely (result < 0)) 
++		return result;
++	return device_create_file(&port->dev, &dev_attr_suspend_status);
++}
++
++static int sierra_remove_sysfs_attrs(struct usb_serial_port *port)
++{
++	device_remove_file(&port->dev, &dev_attr_stats);
++	device_remove_file(&port->dev, &dev_attr_suspend_status);
++	return 0;
++}
++
+ static void sierra_outdat_callback(struct urb *urb)
+ {
+ 	struct usb_serial_port *port = urb->context;
+@@ -451,16 +600,20 @@ static void sierra_outdat_callback(struc
+ 	dev_dbg(&port->dev, "%s - port %d\n", __func__, port->number);
+ 	intfdata = port->serial->private;
+ 
+-	/* free up the transfer buffer, as usb_free_urb() does not do this */
+-	kfree(urb->transfer_buffer);
+ 	usb_autopm_put_interface_async(port->serial->interface);
+-	if (status)
++
++	atomic_inc(&intfdata->stats.outdat_cb_cnt);
++
++	if (status) {
+ 		dev_dbg(&port->dev, "%s - nonzero write bulk status "
+ 		    "received: %d\n", __func__, status);
++		atomic_inc(&intfdata->stats.outdat_cb_fail);
++	}
+ 
+ 	spin_lock(&portdata->lock);
+ 	--portdata->outstanding_urbs;
+ 	spin_unlock(&portdata->lock);
++
+ 	spin_lock(&intfdata->susp_lock);
+ 	--intfdata->in_flight;
+ 	spin_unlock(&intfdata->susp_lock);
+@@ -469,10 +622,11 @@ static void sierra_outdat_callback(struc
+ }
+ 
+ /* Write */
+-static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
+-					const unsigned char *buf, int count)
++static int sierra_write(struct tty_struct *tty, 
++			struct usb_serial_port *port,
++			const unsigned char *buf, int count)
+ {
+-	struct sierra_port_private *portdata;
++	struct sierra_port_private *portdata = usb_get_serial_port_data(port);
+ 	struct sierra_intf_private *intfdata;
+ 	struct usb_serial *serial = port->serial;
+ 	unsigned long flags;
+@@ -485,46 +639,49 @@ static int sierra_write(struct tty_struc
+ 	if (count == 0)
+ 		return 0;
+ 
+-	portdata = usb_get_serial_port_data(port);
++	dev_dbg(&port->dev, "%s: write (%zu bytes)\n", __func__, writesize);
++
+ 	intfdata = serial->private;
+ 
+-	dev_dbg(&port->dev, "%s: write (%zd bytes)\n", __func__, writesize);
+ 	spin_lock_irqsave(&portdata->lock, flags);
+-	dev_dbg(&port->dev, "%s - outstanding_urbs: %d\n", __func__,
+-		portdata->outstanding_urbs);
+ 	if (portdata->outstanding_urbs > portdata->num_out_urbs) {
+ 		spin_unlock_irqrestore(&portdata->lock, flags);
+ 		dev_dbg(&port->dev, "%s - write limit hit\n", __func__);
+ 		return 0;
+ 	}
+ 	portdata->outstanding_urbs++;
+-	dev_dbg(&port->dev, "%s - 1, outstanding_urbs: %d\n", __func__,
+-		portdata->outstanding_urbs);
+ 	spin_unlock_irqrestore(&portdata->lock, flags);
+ 
+ 	retval = usb_autopm_get_interface_async(serial->interface);
+-	if (retval < 0) {
++	if (unlikely(retval < 0)) {
+ 		spin_lock_irqsave(&portdata->lock, flags);
+ 		portdata->outstanding_urbs--;
+ 		spin_unlock_irqrestore(&portdata->lock, flags);
+-		goto error_simple;
++		return retval;
+ 	}
+ 
+ 	buffer = kmalloc(writesize, GFP_ATOMIC);
+ 	if (!buffer) {
+ 		dev_err(&port->dev, "out of memory\n");
+-		retval = -ENOMEM;
+-		goto error_no_buffer;
++		spin_lock_irqsave(&portdata->lock, flags);
++		--portdata->outstanding_urbs;
++		spin_unlock_irqrestore(&portdata->lock, flags);
++		usb_autopm_put_interface_async(serial->interface);
++		return -ENOMEM;
+ 	}
+ 
+ 	urb = usb_alloc_urb(0, GFP_ATOMIC);
+ 	if (!urb) {
+ 		dev_err(&port->dev, "no more free urbs\n");
+-		retval = -ENOMEM;
+-		goto error_no_urb;
++		kfree(buffer);
++		spin_lock_irqsave(&portdata->lock, flags);
++		--portdata->outstanding_urbs;
++		spin_unlock_irqrestore(&portdata->lock, flags);
++		usb_autopm_put_interface_async(serial->interface);
++		return -ENOMEM;
+ 	}
+ 
+-	memcpy(buffer, buf, writesize);
++	memcpy(buffer, buf, writesize); 
+ 
+ 	usb_serial_debug_data(debug, &port->dev, __func__, writesize, buffer);
+ 
+@@ -533,69 +690,73 @@ static int sierra_write(struct tty_struc
+ 					  port->bulk_out_endpointAddress),
+ 			  buffer, writesize, sierra_outdat_callback, port);
+ 
+-	/* Handle the need to send a zero length packet */
+-	urb->transfer_flags |= URB_ZERO_PACKET;
++	/* Handle the need to send a zero length packet and release the
++	 * transfer buffer
++	 */
++	urb->transfer_flags |= (URB_ZERO_PACKET | URB_FREE_BUFFER);
+ 
+ 	spin_lock_irqsave(&intfdata->susp_lock, flags);
+ 
+ 	if (intfdata->suspended) {
+ 		usb_anchor_urb(urb, &portdata->delayed);
+ 		spin_unlock_irqrestore(&intfdata->susp_lock, flags);
+-		goto skip_power;
+-	} else {
+-		usb_anchor_urb(urb, &portdata->active);
++		/* release our reference to this urb, the USB core will 
++		 * eventually free it entirely */
++		usb_free_urb(urb);
++		return writesize;
+ 	}
++	usb_anchor_urb(urb, &portdata->active);
++
+ 	/* send it down the pipe */
+ 	retval = usb_submit_urb(urb, GFP_ATOMIC);
+ 	if (retval) {
+ 		usb_unanchor_urb(urb);
+ 		spin_unlock_irqrestore(&intfdata->susp_lock, flags);
++
+ 		dev_err(&port->dev, "%s - usb_submit_urb(write bulk) failed "
+ 			"with status = %d\n", __func__, retval);
+-		goto error;
++		usb_free_urb(urb);
++		spin_lock_irqsave(&portdata->lock, flags);
++		--portdata->outstanding_urbs;
++		spin_unlock_irqrestore(&portdata->lock, flags);
++		usb_autopm_put_interface_async(serial->interface);
++		atomic_inc(&intfdata->stats.write_err);
++		return retval;
+ 	} else {
+ 		intfdata->in_flight++;
+ 		spin_unlock_irqrestore(&intfdata->susp_lock, flags);
++		atomic_inc(&intfdata->stats.write_cnt);
++		atomic_add(writesize, &intfdata->stats.tx_bytes);
+ 	}
+-
+-skip_power:
+-	/* we are done with this urb, so let the host driver
+-	 * really free it when it is finished with it */
+-	usb_free_urb(urb);
++	/* release our reference to this urb, the USB core will eventually
++	 * free it entirely */
++	usb_free_urb(urb); 
+ 
+ 	return writesize;
+-error:
+-	usb_free_urb(urb);
+-error_no_urb:
+-	kfree(buffer);
+-error_no_buffer:
+-	spin_lock_irqsave(&portdata->lock, flags);
+-	--portdata->outstanding_urbs;
+-	dev_dbg(&port->dev, "%s - 2. outstanding_urbs: %d\n", __func__,
+-		portdata->outstanding_urbs);
+-	spin_unlock_irqrestore(&portdata->lock, flags);
+-	usb_autopm_put_interface_async(serial->interface);
+-error_simple:
+-	return retval;
+ }
+ 
+ static void sierra_indat_callback(struct urb *urb)
+ {
+ 	int err;
+ 	int endpoint;
+-	struct usb_serial_port *port;
++	struct usb_serial_port *port = urb->context;
+ 	struct tty_struct *tty;
++	struct sierra_intf_private *intfdata;
+ 	unsigned char *data = urb->transfer_buffer;
+ 	int status = urb->status;
+ 
+ 	endpoint = usb_pipeendpoint(urb->pipe);
+-	port = urb->context;
+ 
+ 	dev_dbg(&port->dev, "%s: %p\n", __func__, urb);
+ 
++	intfdata = port->serial->private;
++
++	atomic_inc(&intfdata->stats.indat_cb_cnt); /* indat calls */
++
+ 	if (status) {
+ 		dev_dbg(&port->dev, "%s: nonzero status: %d on"
+ 			" endpoint %02x\n", __func__, status, endpoint);
++		atomic_inc(&intfdata->stats.indat_cb_fail); /* indat fails */
+ 	} else {
+ 		if (urb->actual_length) {
+ 			tty = tty_port_tty_get(&port->port);
+@@ -605,6 +766,10 @@ static void sierra_indat_callback(struct
+ 				tty_flip_buffer_push(tty);
+ 
+ 				tty_kref_put(tty);
++				/* tty invalid after this point */
++				/* rx'd bytes */
++				atomic_add(urb->actual_length,
++				&intfdata->stats.rx_bytes);
+ 				usb_serial_debug_data(debug, &port->dev,
+ 					__func__, urb->actual_length, data);
+ 			}
+@@ -615,10 +780,10 @@ static void sierra_indat_callback(struct
+ 	}
+ 
+ 	/* Resubmit urb so we continue receiving */
+-	if (status != -ESHUTDOWN && status != -EPERM) {
++	if (status != -ESHUTDOWN && status != -ENOENT && status != -ENODEV) {
+ 		usb_mark_last_busy(port->serial->dev);
+ 		err = usb_submit_urb(urb, GFP_ATOMIC);
+-		if (err && err != -EPERM)
++		if (err && err != -ENODEV)
+ 			dev_err(&port->dev, "resubmit read urb failed."
+ 				"(%d)\n", err);
+ 	}
+@@ -634,31 +799,29 @@ static void sierra_instat_callback(struc
+ 	struct sierra_port_private *portdata = usb_get_serial_port_data(port);
+ 	struct usb_serial *serial = port->serial;
+ 
+-	dev_dbg(&port->dev, "%s: urb %p port %p has data %p\n", __func__,
+-		urb, port, portdata);
++	dev_dbg(&port->dev, "%s: %p\n", __func__, urb);
+ 
+ 	if (status == 0) {
+ 		struct usb_ctrlrequest *req_pkt =
+ 				(struct usb_ctrlrequest *)urb->transfer_buffer;
+ 
+-		if (!req_pkt) {
+-			dev_dbg(&port->dev, "%s: NULL req_pkt\n",
+-				__func__);
+-			return;
+-		}
+-		if ((req_pkt->bRequestType == 0xA1) &&
+-				(req_pkt->bRequest == 0x20)) {
++		const u16 *sigp = (u16 *)(req_pkt + 1);
++		/* usb_ctrlrequest we parsed is followed by two bytes of data
++		 * make sure we received that many bytes
++		 */
++		if (urb->actual_length >= sizeof(*req_pkt) + sizeof(*sigp) &&
++			req_pkt->bRequestType == USB_REQUEST_TYPE_CLASS && 
++			req_pkt->bRequest == USB_REQUEST_IFACE) {
+ 			int old_dcd_state;
+-			unsigned char signals = *((unsigned char *)
+-					urb->transfer_buffer +
+-					sizeof(struct usb_ctrlrequest));
++			const u16 signals = get_unaligned_le16(sigp);
+ 			struct tty_struct *tty;
+ 
+-			dev_dbg(&port->dev, "%s: signal x%x\n", __func__,
++			dev_dbg(&port->dev, "%s: signal 0x%x\n", __func__,
+ 				signals);
+ 
+ 			old_dcd_state = portdata->dcd_state;
+-			portdata->cts_state = 1;
++			/* Note: CTS from modem is in reverse logic! */
++			portdata->cts_state = ((signals & 0x100) ? 0 : 1);
+ 			portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
+ 			portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
+ 			portdata->ri_state = ((signals & 0x08) ? 1 : 0);
+@@ -669,19 +832,19 @@ static void sierra_instat_callback(struc
+ 				tty_hangup(tty);
+ 			tty_kref_put(tty);
+ 		} else {
+-			dev_dbg(&port->dev, "%s: type %x req %x\n",
+-				__func__, req_pkt->bRequestType,
+-				req_pkt->bRequest);
++			/* dump the data we don't understand to log */
++			usb_serial_debug_data(1, &port->dev, __func__,
++				urb->actual_length, urb->transfer_buffer);
+ 		}
+ 	} else
+ 		dev_dbg(&port->dev, "%s: error %d\n", __func__, status);
+ 
+ 	/* Resubmit urb so we continue receiving IRQ data */
+-	if (status != -ESHUTDOWN && status != -ENOENT) {
++	if (status != -ESHUTDOWN && status != -ENOENT && status != -ENODEV) {
+ 		usb_mark_last_busy(serial->dev);
+ 		urb->dev = serial->dev;
+ 		err = usb_submit_urb(urb, GFP_ATOMIC);
+-		if (err && err != -EPERM)
++		if (err && err != -ENODEV)
+ 			dev_err(&port->dev, "%s: resubmit intr urb "
+ 				"failed. (%d)\n", __func__, err);
+ 	}
+@@ -692,20 +855,21 @@ static int sierra_write_room(struct tty_
+ 	struct usb_serial_port *port = tty->driver_data;
+ 	struct sierra_port_private *portdata = usb_get_serial_port_data(port);
+ 	unsigned long flags;
++	int retval;
+ 
+ 	dev_dbg(&port->dev, "%s - port %d\n", __func__, port->number);
+ 
+ 	/* try to give a good number back based on if we have any free urbs at
+ 	 * this point in time */
++	retval = MAX_TRANSFER;
++
+ 	spin_lock_irqsave(&portdata->lock, flags);
+-	if (portdata->outstanding_urbs > (portdata->num_out_urbs * 2) / 3) {
+-		spin_unlock_irqrestore(&portdata->lock, flags);
+-		dev_dbg(&port->dev, "%s - write limit hit\n", __func__);
+-		return 0;
++	if (portdata->outstanding_urbs >= portdata->num_out_urbs) {
++		retval = 0;
+ 	}
+ 	spin_unlock_irqrestore(&portdata->lock, flags);
+ 
+-	return 2048;
++	return retval;
+ }
+ 
+ static void sierra_stop_rx_urbs(struct usb_serial_port *port)
+@@ -732,6 +896,7 @@ static int sierra_submit_rx_urbs(struct 
+ 		urb = portdata->in_urbs[i];
+ 		if (!urb)
+ 			continue;
++		urb->transfer_flags |= URB_FREE_BUFFER;
+ 		err = usb_submit_urb(urb, mem_flags);
+ 		if (err) {
+ 			dev_err(&port->dev, "%s: submit urb failed: %d\n",
+@@ -793,34 +958,31 @@ static struct urb *sierra_setup_urb(stru
+ 
+ 	return urb;
+ }
+-
+ static void sierra_close(struct usb_serial_port *port)
+ {
+ 	int i;
++	struct urb	*urb;
+ 	struct usb_serial *serial = port->serial;
+ 	struct sierra_port_private *portdata;
+ 	struct sierra_intf_private *intfdata = port->serial->private;
+ 
+-
+ 	dev_dbg(&port->dev, "%s\n", __func__);
+ 	portdata = usb_get_serial_port_data(port);
+ 
+ 	portdata->rts_state = 0;
+ 	portdata->dtr_state = 0;
+ 
++	usb_autopm_get_interface(serial->interface);
++
+ 	if (serial->dev) {
+ 		mutex_lock(&serial->disc_mutex);
+-		if (!serial->disconnected) {
+-			serial->interface->needs_remote_wakeup = 0;
+-			usb_autopm_get_interface(serial->interface);
++		if (!serial->disconnected)
+ 			sierra_send_setup(port);
+-		}
+ 		mutex_unlock(&serial->disc_mutex);
+ 		spin_lock_irq(&intfdata->susp_lock);
+ 		portdata->opened = 0;
+ 		spin_unlock_irq(&intfdata->susp_lock);
+ 
+-
+ 		/* Stop reading urbs */
+ 		sierra_stop_rx_urbs(port);
+ 		/* .. and release them */
+@@ -828,6 +990,14 @@ static void sierra_close(struct usb_seri
+ 			sierra_release_urb(portdata->in_urbs[i]);
+ 			portdata->in_urbs[i] = NULL;
+ 		}
++		while((urb = usb_get_from_anchor(&portdata->delayed))) {
++			sierra_release_urb(urb);
++			usb_autopm_put_interface(serial->interface);
++		}
++		/* wait for active to finish */
++		usb_wait_anchor_empty_timeout(&portdata->active, 500);
++		usb_kill_anchored_urbs(&portdata->active);
++
+ 	}
+ }
+ 
+@@ -861,17 +1031,41 @@ static int sierra_open(struct tty_struct
+ 	usb_clear_halt(serial->dev,
+ 			usb_sndbulkpipe(serial->dev, endpoint) | USB_DIR_IN);
+ 
++	/* reset outstanding out urbs counter */
++	spin_lock_irq(&portdata->lock);
++	portdata->outstanding_urbs = 0;
++	spin_unlock_irq(&portdata->lock);
++
+ 	err = sierra_submit_rx_urbs(port, GFP_KERNEL);
+ 	if (err) {
+-		/* get rid of everything as in close */
+-		sierra_close(port);
++		/* do everything as in close() but do not call close() because
++		 * usbserial calls sierra_open() with mutex taken;
++		 * then if we call sierra_close() inside sierra_open() we
++		 * violate 'no nested mutexes' kernel condition
++		 */
++		portdata->rts_state = 0;
++		portdata->dtr_state = 0;
++		usb_autopm_get_interface(serial->interface);
++		/* Stop reading urbs */
++		sierra_stop_rx_urbs(port);
++		/* .. and release them */
++		for (i = 0; i < portdata->num_in_urbs; i++) {
++			sierra_release_urb(portdata->in_urbs[i]);
++			portdata->in_urbs[i] = NULL;
++		}
++		while((urb = usb_get_from_anchor(&portdata->delayed))) {
++			sierra_release_urb(urb);
++			usb_autopm_put_interface(serial->interface);
++		}
++		/* wait for active to finish */
++		usb_wait_anchor_empty_timeout(&portdata->active, 500);
++		usb_kill_anchored_urbs(&portdata->active);
+ 		/* restore balance for autopm */
+ 		usb_autopm_put_interface(serial->interface);
+ 		return err;
+ 	}
+ 	sierra_send_setup(port);
+ 
+-	serial->interface->needs_remote_wakeup = 1;
+ 	spin_lock_irq(&intfdata->susp_lock);
+ 	portdata->opened = 1;
+ 	spin_unlock_irq(&intfdata->susp_lock);
+@@ -880,7 +1074,6 @@ static int sierra_open(struct tty_struct
+ 	return 0;
+ }
+ 
+-
+ static void sierra_dtr_rts(struct usb_serial_port *port, int on)
+ {
+ 	struct usb_serial *serial = port->serial;
+@@ -900,11 +1093,13 @@ static void sierra_dtr_rts(struct usb_se
+ 
+ static int sierra_startup(struct usb_serial *serial)
+ {
+-	struct usb_serial_port *port;
+-	struct sierra_port_private *portdata;
++	struct usb_serial_port *port = NULL;
++	struct sierra_port_private *portdata = NULL;
+ 	struct sierra_iface_info *himemoryp = NULL;
+ 	int i;
+ 	u8 ifnum;
++	u16 fw_attr;
++	int result;
+ 
+ 	dev_dbg(&serial->dev->dev, "%s\n", __func__);