path: root/abs/core/lirc/kernel-2.6.35.patch

--- drivers/lirc_atiusb/lirc_atiusb.c	2009/03/11 00:21:46	1.85
+++ drivers/lirc_atiusb/lirc_atiusb.c	2010/03/17 14:16:15	1.86
@@ -17,7 +17,7 @@
  *   Vassilis Virvilis <vasvir@iit.demokritos.gr> 2006
  *      reworked the patch for lirc submission
  *
- * $Id: lirc_atiusb.c,v 1.85 2009/03/11 00:21:46 jarodwilson Exp $
+ * $Id: lirc_atiusb.c,v 1.86 2010/03/17 14:16:15 jarodwilson Exp $
  */
 
 /*
@@ -67,7 +69,7 @@
 #include "drivers/kcompat.h"
 #include "drivers/lirc_dev/lirc_dev.h"
 
-#define DRIVER_VERSION		"$Revision: 1.85 $"
+#define DRIVER_VERSION		"$Revision: 1.86 $"
 #define DRIVER_AUTHOR		"Paul Miller <pmiller9@users.sourceforge.net>"
 #define DRIVER_DESC		"USB remote driver for LIRC"
 #define DRIVER_NAME		"lirc_atiusb"
@@ -1374,7 +1376,7 @@
 	       DRIVER_VERSION "\n");
 	printk(DRIVER_NAME ": " DRIVER_AUTHOR "\n");
 	dprintk(DRIVER_NAME ": debug mode enabled: "
-		"$Id: lirc_atiusb.c,v 1.85 2009/03/11 00:21:46 jarodwilson Exp $\n");
+		"$Id: lirc_atiusb.c,v 1.86 2010/03/17 14:16:15 jarodwilson Exp $\n");
 
 	repeat_jiffies = repeat*HZ/100;
 
--- drivers/lirc_atiusb/lirc_atiusb.c	2010/03/17 14:16:15	1.86
+++ drivers/lirc_atiusb/lirc_atiusb.c	2010/07/24 14:35:58	1.87
@@ -17,7 +17,7 @@
  *   Vassilis Virvilis <vasvir@iit.demokritos.gr> 2006
  *      reworked the patch for lirc submission
  *
- * $Id: lirc_atiusb.c,v 1.86 2010/03/17 14:16:15 jarodwilson Exp $
+ * $Id: lirc_atiusb.c,v 1.87 2010/07/24 14:35:58 jarodwilson Exp $
  */
 
 /*
@@ -69,7 +69,7 @@
 #include "drivers/kcompat.h"
 #include "drivers/lirc_dev/lirc_dev.h"
 
-#define DRIVER_VERSION		"$Revision: 1.86 $"
+#define DRIVER_VERSION		"$Revision: 1.87 $"
 #define DRIVER_AUTHOR		"Paul Miller <pmiller9@users.sourceforge.net>"
 #define DRIVER_DESC		"USB remote driver for LIRC"
 #define DRIVER_NAME		"lirc_atiusb"
@@ -824,7 +824,11 @@
 				ir->devnum);
 	case 3:
 #ifdef KERNEL_2_5
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 34)
+		usb_free_coherent(iep->ir->usbdev, iep->len, iep->buf, iep->dma);
+#else
 		usb_buffer_free(iep->ir->usbdev, iep->len, iep->buf, iep->dma);
+#endif
 #else
 		kfree(iep->buf);
 #endif
@@ -869,7 +873,11 @@
 	iep->len = len;
 
 #ifdef KERNEL_2_5
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 34)
+	iep->buf = usb_alloc_coherent(dev, len, GFP_ATOMIC, &iep->dma);
+#else
 	iep->buf = usb_buffer_alloc(dev, len, GFP_ATOMIC, &iep->dma);
+#endif
 #else
 	iep->buf = kmalloc(len, GFP_KERNEL);
 #endif
@@ -931,8 +939,13 @@
 		}
 	case 3:
 #ifdef KERNEL_2_5
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 34)
+		usb_free_coherent(oep->ir->usbdev, USB_OUTLEN,
+				  oep->buf, oep->dma);
+#else
 		usb_buffer_free(oep->ir->usbdev, USB_OUTLEN,
 				oep->buf, oep->dma);
+#endif
 #else
 		kfree(oep->buf);
 #endif
@@ -965,8 +978,13 @@
 		init_waitqueue_head(&oep->wait);
 
 #ifdef KERNEL_2_5
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 34)
+		oep->buf = usb_alloc_coherent(dev, USB_OUTLEN,
+					      GFP_ATOMIC, &oep->dma);
+#else
 		oep->buf = usb_buffer_alloc(dev, USB_OUTLEN,
 					    GFP_ATOMIC, &oep->dma);
+#endif
 #else
 		oep->buf = kmalloc(USB_OUTLEN, GFP_KERNEL);
 #endif
@@ -1376,7 +1394,7 @@
 	       DRIVER_VERSION "\n");
 	printk(DRIVER_NAME ": " DRIVER_AUTHOR "\n");
 	dprintk(DRIVER_NAME ": debug mode enabled: "
-		"$Id: lirc_atiusb.c,v 1.86 2010/03/17 14:16:15 jarodwilson Exp $\n");
+		"$Id: lirc_atiusb.c,v 1.87 2010/07/24 14:35:58 jarodwilson Exp $\n");
 
 	repeat_jiffies = repeat*HZ/100;

--- drivers/lirc_atiusb/lirc_atiusb.c	2010/07/24 14:35:58	1.87
+++ drivers/lirc_atiusb/lirc_atiusb.c	2010/07/25 16:43:33	1.88
@@ -17,7 +17,7 @@
  *   Vassilis Virvilis <vasvir@iit.demokritos.gr> 2006
  *      reworked the patch for lirc submission
  *
- * $Id: lirc_atiusb.c,v 1.87 2010/07/24 14:35:58 jarodwilson Exp $
+ * $Id: lirc_atiusb.c,v 1.88 2010/07/25 16:43:33 jarodwilson Exp $
  */
 
 /*
@@ -69,7 +69,7 @@
 #include "drivers/kcompat.h"
 #include "drivers/lirc_dev/lirc_dev.h"
 
-#define DRIVER_VERSION		"$Revision: 1.87 $"
+#define DRIVER_VERSION		"$Revision: 1.88 $"
 #define DRIVER_AUTHOR		"Paul Miller <pmiller9@users.sourceforge.net>"
 #define DRIVER_DESC		"USB remote driver for LIRC"
 #define DRIVER_NAME		"lirc_atiusb"
@@ -824,12 +824,8 @@
 				ir->devnum);
 	case 3:
 #ifdef KERNEL_2_5
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 34)
 		usb_free_coherent(iep->ir->usbdev, iep->len, iep->buf, iep->dma);
 #else
-		usb_buffer_free(iep->ir->usbdev, iep->len, iep->buf, iep->dma);
-#endif
-#else
 		kfree(iep->buf);
 #endif
 		iep->buf = 0;
@@ -873,12 +869,8 @@
 	iep->len = len;
 
 #ifdef KERNEL_2_5
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 34)
 	iep->buf = usb_alloc_coherent(dev, len, GFP_ATOMIC, &iep->dma);
 #else
-	iep->buf = usb_buffer_alloc(dev, len, GFP_ATOMIC, &iep->dma);
-#endif
-#else
 	iep->buf = kmalloc(len, GFP_KERNEL);
 #endif
 	if (!iep->buf) {
@@ -939,14 +931,9 @@
 		}
 	case 3:
 #ifdef KERNEL_2_5
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 34)
 		usb_free_coherent(oep->ir->usbdev, USB_OUTLEN,
 				  oep->buf, oep->dma);
 #else
-		usb_buffer_free(oep->ir->usbdev, USB_OUTLEN,
-				oep->buf, oep->dma);
-#endif
-#else
 		kfree(oep->buf);
 #endif
 		oep->buf = 0;
@@ -978,14 +965,9 @@
 		init_waitqueue_head(&oep->wait);
 
 #ifdef KERNEL_2_5
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 34)
 		oep->buf = usb_alloc_coherent(dev, USB_OUTLEN,
 					      GFP_ATOMIC, &oep->dma);
 #else
-		oep->buf = usb_buffer_alloc(dev, USB_OUTLEN,
-					    GFP_ATOMIC, &oep->dma);
-#endif
-#else
 		oep->buf = kmalloc(USB_OUTLEN, GFP_KERNEL);
 #endif
 		if (!oep->buf)
@@ -1394,7 +1376,7 @@
 	       DRIVER_VERSION "\n");
 	printk(DRIVER_NAME ": " DRIVER_AUTHOR "\n");
 	dprintk(DRIVER_NAME ": debug mode enabled: "
-		"$Id: lirc_atiusb.c,v 1.87 2010/07/24 14:35:58 jarodwilson Exp $\n");
+		"$Id: lirc_atiusb.c,v 1.88 2010/07/25 16:43:33 jarodwilson Exp $\n");
 
 	repeat_jiffies = repeat*HZ/100;
 
--- drivers/kcompat.h	2009/08/02 11:15:28	5.45
+++ drivers/kcompat.h	2010/07/27 05:43:21	5.50
@@ -1,4 +1,4 @@
-/*      $Id: kcompat.h,v 5.45 2009/08/02 11:15:28 lirc Exp $      */
+/*      $Id: kcompat.h,v 5.50 2010/07/27 05:43:21 jarodwilson Exp $      */
 
 #ifndef _KCOMPAT_H
 #define _KCOMPAT_H
@@ -9,6 +9,11 @@
 #define __func__ __FUNCTION__
 #endif
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 34)
+#define usb_alloc_coherent usb_buffer_alloc
+#define usb_free_coherent usb_buffer_free
+#endif
+
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 16)
 #define LIRC_THIS_MODULE(x) x,
 #else /* >= 2.6.16 */
@@ -364,6 +369,11 @@
 #endif /* kernel < 2.6.11 */
 #endif /* kernel >= 2.6.0 */
 
+/*************************** pm_wakeup.h ******************************/
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27)
+static inline void device_set_wakeup_capable(struct device *dev, int val) {}
+#endif /* kernel < 2.6.27 */
+
 /*************************** interrupt.h ******************************/
 /* added in 2.6.18, old defines removed in 2.6.24 */
 #ifndef IRQF_DISABLED
@@ -378,6 +388,9 @@
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11)
 #define DEFINE_SPINLOCK(x) spinlock_t x = SPIN_LOCK_UNLOCKED
 #endif
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
+#define __SPIN_LOCK_UNLOCKED(x) SPIN_LOCK_UNLOCKED;
+#endif
 
 /***************************** slab.h *********************************/
 /* added in 2.6.14 */
@@ -405,4 +418,14 @@
 #define BIT_WORD(nr)            ((nr) / BITS_PER_LONG)
 #endif
 
+/****************************** kernel.h **********************************/
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 29)
+#define DIV_ROUND_CLOSEST(x, divisor)(                  \
+{                                                       \
+        typeof(divisor) __divisor = divisor;            \
+        (((x) + ((__divisor) / 2)) / (__divisor));      \
+}                                                       \
+)
+#endif
+
 #endif /* _KCOMPAT_H */
--- drivers/lirc_igorplugusb/lirc_igorplugusb.c	2009/11/09 18:59:21	1.35
+++ drivers/lirc_igorplugusb/lirc_igorplugusb.c	2010/07/25 16:43:33	1.38
@@ -450,7 +452,7 @@
 	}
 
 #if defined(KERNEL_2_5)
-	ir->buf_in = usb_buffer_alloc(dev,
+	ir->buf_in = usb_alloc_coherent(dev,
 			      DEVICE_BUFLEN+DEVICE_HEADERLEN,
 			      GFP_ATOMIC, &ir->dma_in);
 #else
@@ -486,7 +488,7 @@
 	switch (mem_failure) {
 	case 9:
 #if defined(KERNEL_2_5)
-		usb_buffer_free(dev, DEVICE_BUFLEN+DEVICE_HEADERLEN,
+		usb_free_coherent(dev, DEVICE_BUFLEN+DEVICE_HEADERLEN,
 			ir->buf_in, ir->dma_in);
 #else
 		kfree(ir->buf_in);
@@ -566,7 +568,7 @@
 
 
 #if defined(KERNEL_2_5)
-	usb_buffer_free(dev, ir->len_in, ir->buf_in, ir->dma_in);
+	usb_free_coherent(dev, ir->len_in, ir->buf_in, ir->dma_in);
 #else
 	kfree(ir->buf_in);
 #endif
--- drivers/lirc_mceusb/lirc_mceusb.c	2010/03/17 14:16:16	1.54
+++ drivers/lirc_mceusb/lirc_mceusb.c	2010/07/25 16:43:33	1.70
@@ -80,6 +80,7 @@
 #define DRIVER_NAME	"lirc_mceusb"
 
 #define USB_BUFLEN	32	/* USB reception buffer length */
+#define USB_CTRL_MSG_SZ	2	/* Size of usb ctrl msg on gen1 hw */
 #define LIRCBUF_SIZE	256	/* LIRC work buffer length */
 
 /* MCE constants */
@@ -95,7 +96,7 @@
 #define MCE_PULSE_BIT	0x80 /* Pulse bit, MSB set == PULSE else SPACE */
 #define MCE_PULSE_MASK	0x7F /* Pulse mask */
 #define MCE_MAX_PULSE_LENGTH 0x7F /* Longest transmittable pulse symbol */
-#define MCE_PACKET_LENGTH_MASK  0x7F /* Pulse mask */
+#define MCE_PACKET_LENGTH_MASK  0x7F /* Packet length mask */
 
 
 /* module parameters */
@@ -116,8 +117,8 @@
 #define RECV_FLAG_IN_PROGRESS	3
 #define RECV_FLAG_COMPLETE	4
 
-#define MCEUSB_INBOUND		1
-#define MCEUSB_OUTBOUND		2
+#define MCEUSB_RX		1
+#define MCEUSB_TX		2
 
 #define VENDOR_PHILIPS		0x0471
 #define VENDOR_SMK		0x0609
@@ -211,6 +212,8 @@
 	{ USB_DEVICE(VENDOR_FORMOSA, 0xe03a) },
 	/* Formosa Industrial Computing AIM IR605/A */
 	{ USB_DEVICE(VENDOR_FORMOSA, 0xe03c) },
+	/* Formosa Industrial Computing AIM IR605/A */
+	{ USB_DEVICE(VENDOR_FORMOSA, 0xe03e) },
 	/* Fintek eHome Infrared Transceiver */
 	{ USB_DEVICE(VENDOR_FINTEK, 0x0602) },
 	/* Fintek eHome Infrared Transceiver (in the AOpen MP45) */
@@ -233,8 +236,9 @@
 	{ }
 };
 
-static struct usb_device_id pinnacle_list[] = {
+static struct usb_device_id gen3_list[] = {
 	{ USB_DEVICE(VENDOR_PINNACLE, 0x0225) },
+	{ USB_DEVICE(VENDOR_TOPSEED, 0x0008) },
 	{}
 };
 
@@ -282,10 +286,9 @@
 	unsigned char is_pulse;
 	struct {
 		u32 connected:1;
-		u32 pinnacle:1;
 		u32 transmitter_mask_inverted:1;
 		u32 microsoft_gen1:1;
-		u32 reserved:28;
+		u32 reserved:29;
 	} flags;
 
 	unsigned char transmitter_mask;
@@ -295,16 +298,44 @@
 	int send_flags;
 	wait_queue_head_t wait_out;
 
-	struct mutex lock;
+	struct mutex dev_lock;
 };
 
-/* init strings */
-static char init1[] = {0x00, 0xff, 0xaa, 0xff, 0x0b};
-static char init2[] = {0xff, 0x18};
-
-static char pin_init1[] = { 0x9f, 0x07};
-static char pin_init2[] = { 0x9f, 0x13};
-static char pin_init3[] = { 0x9f, 0x0d};
+/*
+ * MCE Device Command Strings
+ * Device command responses vary from device to device...
+ * - DEVICE_RESET resets the hardware to its default state
+ * - GET_REVISION fetches the hardware/software revision, common
+ *   replies are ff 0b 45 ff 1b 08 and ff 0b 50 ff 1b 42
+ * - GET_CARRIER_FREQ gets the carrier mode and frequency of the
+ *   device, with replies in the form of 9f 06 MM FF, where MM is 0-3,
+ *   meaning clk of 10000000, 2500000, 625000 or 156250, and FF is
+ *   ((clk / frequency) - 1)
+ * - GET_RX_TIMEOUT fetches the receiver timeout in units of 50us,
+ *   response in the form of 9f 0c msb lsb
+ * - GET_TX_BITMASK fetches the transmitter bitmask, replies in
+ *   the form of 9f 08 bm, where bm is the bitmask
+ * - GET_RX_SENSOR fetches the RX sensor setting -- long-range
+ *   general use one or short-range learning one, in the form of
+ *   9f 14 ss, where ss is either 01 for long-range or 02 for short
+ * - SET_CARRIER_FREQ sets a new carrier mode and frequency
+ * - SET_TX_BITMASK sets the transmitter bitmask
+ * - SET_RX_TIMEOUT sets the receiver timeout
+ * - SET_RX_SENSOR sets which receiver sensor to use
+ */
+static char DEVICE_RESET[]	= {0x00, 0xff, 0xaa};
+static char GET_REVISION[]	= {0xff, 0x0b};
+static char GET_UNKNOWN[]	= {0xff, 0x18};
+static char GET_UNKNOWN2[]	= {0x9f, 0x05};
+static char GET_CARRIER_FREQ[]	= {0x9f, 0x07};
+static char GET_RX_TIMEOUT[]	= {0x9f, 0x0d};
+static char GET_TX_BITMASK[]	= {0x9f, 0x13};
+static char GET_RX_SENSOR[]	= {0x9f, 0x15};
+/* sub in desired values in lower byte or bytes for full command */
+//static char SET_CARRIER_FREQ[]	= {0x9f, 0x06, 0x00, 0x00};
+//static char SET_TX_BITMASK[]	= {0x9f, 0x08, 0x00};
+//static char SET_RX_TIMEOUT[]	= {0x9f, 0x0c, 0x00, 0x00};
+//static char SET_RX_SENSOR[]	= {0x9f, 0x14, 0x00};
 
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11)
 static unsigned long usecs_to_jiffies(const unsigned int u)
@@ -320,22 +351,126 @@
 #endif
 }
 #endif
-static void mceusb_dev_printdata(struct mceusb_dev *ir, char *buf, int len)
+static void mceusb_dev_printdata(struct mceusb_dev *ir, char *buf,
+				 int len, bool out)
 {
 	char codes[USB_BUFLEN * 3 + 1];
+	char inout[9];
 	int i;
+	u8 cmd, subcmd, data1, data2;
+	int idx = 0;
 
-	if (len <= 0)
-		return;
+	if (ir->flags.microsoft_gen1 && !out)
+		idx = 2;
 
-	if (ir->flags.microsoft_gen1 && len <= 2)
+	if (len <= idx)
 		return;
 
 	for (i = 0; i < len && i < USB_BUFLEN; i++)
 		snprintf(codes + i * 3, 4, "%02x ", buf[i] & 0xFF);
 
-	printk(KERN_INFO "" DRIVER_NAME "[%d]: data received %s (length=%d)\n",
-		ir->devnum, codes, len);
+	printk(KERN_INFO "" DRIVER_NAME "[%d]: %sx data: %s (length=%d)\n",
+		ir->devnum, (out ? "t" : "r"), codes, len);
+
+	if (out)
+		strcpy(inout, "Request\0");
+	else
+		strcpy(inout, "Got\0");
+
+	cmd    = buf[idx] & 0xff;
+	subcmd = buf[idx + 1] & 0xff;
+	data1  = buf[idx + 2] & 0xff;
+	data2  = buf[idx + 3] & 0xff;
+
+	switch (cmd) {
+	case 0x00:
+		if (subcmd == 0xff && data1 == 0xaa)
+			printk(KERN_INFO "Device reset requested\n");
+		else
+			printk(KERN_INFO "Unknown command 0x%02x 0x%02x\n",
+				cmd, subcmd);
+		break;
+	case 0xff:
+		switch (subcmd) {
+		case 0x0b:
+			if (len == 2)
+				printk(KERN_INFO "Get hw/sw rev?\n");
+			else
+				printk(KERN_INFO "hw/sw rev 0x%02x 0x%02x "
+					"0x%02x 0x%02x\n", data1, data2,
+					buf[4], buf[5]);
+			break;
+		case 0xaa:
+			printk(KERN_INFO "Device reset requested\n");
+			break;
+		case 0xfe:
+			printk(KERN_INFO "Previous command not supported\n");
+			break;
+		case 0x18:
+		case 0x1b:
+		default:
+			printk(KERN_INFO "Unknown command 0x%02x 0x%02x\n",
+				cmd, subcmd);
+			break;
+		}
+		break;
+	case 0x9f:
+		switch (subcmd) {
+		case 0x03:
+			printk(KERN_INFO "Ping\n");
+			break;
+		case 0x04:
+			printk(KERN_INFO "Resp to 9f 05 of 0x%02x 0x%02x\n",
+				data1, data2);
+			break;
+		case 0x06:
+			printk(KERN_INFO "%s carrier mode and freq of 0x%02x 0x%02x\n",
+				inout, data1, data2);
+			break;
+		case 0x07:
+			printk(KERN_INFO "Get carrier mode and freq\n");
+			break;
+		case 0x08:
+			printk(KERN_INFO "%s transmit blaster mask of 0x%02x\n",
+				inout, data1);
+			break;
+		case 0x0c:
+			/* value is in units of 50us, so x*50/100 or x/2 ms */
+			printk(KERN_INFO "%s receive timeout of %d ms\n",
+				inout, ((data1 << 8) | data2) / 2);
+			break;
+		case 0x0d:
+			printk(KERN_INFO "Get receive timeout\n");
+			break;
+		case 0x13:
+			printk(KERN_INFO "Get transmit blaster mask\n");
+			break;
+		case 0x14:
+			printk(KERN_INFO "%s %s-range receive sensor in use\n",
+				inout, data1 == 0x02 ? "short" : "long");
+			break;
+		case 0x15:
+			if (len == 2)
+				printk(KERN_INFO "Get receive sensor\n");
+			else
+				printk(KERN_INFO "Received pulse count is %d\n",
+					((data1 << 8) | data2));
+			break;
+		case 0xfe:
+			printk(KERN_INFO "Error! Hardware is likely wedged...\n");
+			break;
+		case 0x05:
+		case 0x09:
+		case 0x0f:
+		default:
+			printk(KERN_INFO "Unknown command 0x%02x 0x%02x\n",
+				cmd, subcmd);
+			break;
+		}
+		break;
+	default:
+		break;
+	}
 }
 
 static void usb_async_callback(struct urb *urb, struct pt_regs *regs)
@@ -355,54 +490,48 @@
 			ir->devnum, urb->status, len);
 
 		if (debug)
-			mceusb_dev_printdata(ir, urb->transfer_buffer, len);
+			mceusb_dev_printdata(ir, urb->transfer_buffer, len, true);
 	}
 
 }
 
 /* request incoming or send outgoing usb packet - used to initialize remote */
-static void request_packet_async(struct mceusb_dev *ir,
-				 struct usb_endpoint_descriptor *ep,
-				 unsigned char *data, int size, int urb_type)
+static void mce_request_packet(struct mceusb_dev *ir,
+			       struct usb_endpoint_descriptor *ep,
+			       unsigned char *data, int size, int urb_type)
 {
 	int res;
 	struct urb *async_urb;
 	unsigned char *async_buf;
 
-	if (urb_type) {
+	if (urb_type == MCEUSB_TX) {
 		async_urb = usb_alloc_urb(0, GFP_KERNEL);
-		if (unlikely(!async_urb))
+		if (unlikely(!async_urb)) {
+			printk(KERN_ERR "Error, couldn't allocate urb!\n");
 			return;
+		}
 
-		async_buf = kmalloc(size, GFP_KERNEL);
+		async_buf = kzalloc(size, GFP_KERNEL);
 		if (!async_buf) {
+			printk(KERN_ERR "Error, couldn't allocate buf!\n");
 			usb_free_urb(async_urb);
 			return;
 		}
 
-		if (urb_type == MCEUSB_OUTBOUND) {
-			/* outbound data */
-			usb_fill_int_urb(async_urb, ir->usbdev,
-				usb_sndintpipe(ir->usbdev,
-					ep->bEndpointAddress),
-				async_buf, size,
-				(usb_complete_t) usb_async_callback,
-				ir, ep->bInterval);
-			memcpy(async_buf, data, size);
-		} else {
-			/* inbound data */
-			usb_fill_int_urb(async_urb, ir->usbdev,
-				usb_rcvintpipe(ir->usbdev,
-					ep->bEndpointAddress),
-				async_buf, size,
-				(usb_complete_t) usb_async_callback,
-				ir, ep->bInterval);
-		}
-		async_urb->transfer_flags = URB_ASYNC_UNLINK;
-	} else {
+		/* outbound data */
+		usb_fill_int_urb(async_urb, ir->usbdev,
+			usb_sndintpipe(ir->usbdev, ep->bEndpointAddress),
+			async_buf, size, (usb_complete_t) usb_async_callback,
+			ir, ep->bInterval);
+		memcpy(async_buf, data, size);
+
+	} else if (urb_type == MCEUSB_RX) {
 		/* standard request */
 		async_urb = ir->urb_in;
 		ir->send_flags = RECV_FLAG_IN_PROGRESS;
+	} else {
+		printk(KERN_ERR "Error! Unknown urb type %d\n", urb_type);
+		return;
 	}
 
 	dprintk(DRIVER_NAME "[%d]: receive request called (size=%#x)\n",
@@ -421,6 +550,16 @@
 		ir->devnum, res);
 }
 
+static void mce_async_out(struct mceusb_dev *ir, unsigned char *data, int size)
+{
+	mce_request_packet(ir, ir->usb_ep_out, data, size, MCEUSB_TX);
+}
+
+static void mce_sync_in(struct mceusb_dev *ir, unsigned char *data, int size)
+{
+	mce_request_packet(ir, ir->usb_ep_in, data, size, MCEUSB_RX);
+}
+
 static int unregister_from_lirc(struct mceusb_dev *ir)
 {
 	struct lirc_driver *d = ir->d;
@@ -496,9 +635,9 @@
 	dprintk(DRIVER_NAME "[%d]: mceusb IR device closed\n", ir->devnum);
 
 	if (ir->flags.connected) {
-		mutex_lock(&ir->lock);
+		mutex_lock(&ir->dev_lock);
 		ir->flags.connected = 0;
-		mutex_unlock(&ir->lock);
+		mutex_unlock(&ir->dev_lock);
 	}
 	MOD_DEC_USE_COUNT;
 }
@@ -616,7 +755,7 @@
 	buf_len = urb->actual_length;
 
 	if (debug)
-		mceusb_dev_printdata(ir, urb->transfer_buffer, buf_len);
+		mceusb_dev_printdata(ir, urb->transfer_buffer, buf_len, false);
 
 	if (ir->send_flags == RECV_FLAG_IN_PROGRESS) {
 		ir->send_flags = SEND_FLAG_COMPLETE;
@@ -715,8 +854,7 @@
 	cmdbuf[cmdcount++] = 0x80;
 
 	/* Transmit the command to the mce device */
-	request_packet_async(ir, ir->usb_ep_out, cmdbuf,
-			     cmdcount, MCEUSB_OUTBOUND);
+	mce_async_out(ir, cmdbuf, cmdcount);
 
 	/*
 	 * The lircd gap calculation expects the write function to
@@ -762,9 +900,7 @@
 			ir->carrier_freq = carrier;
 			dprintk(DRIVER_NAME "[%d]: SET_CARRIER disabling "
 				"carrier modulation\n", ir->devnum);
-			request_packet_async(ir, ir->usb_ep_out,
-					     cmdbuf, sizeof(cmdbuf),
-					     MCEUSB_OUTBOUND);
+			mce_async_out(ir, cmdbuf, sizeof(cmdbuf));
 			return carrier;
 		}
 
@@ -779,9 +915,7 @@
 					ir->devnum, carrier);
 
 				/* Transmit new carrier to mce device */
-				request_packet_async(ir, ir->usb_ep_out,
-						     cmdbuf, sizeof(cmdbuf),
-						     MCEUSB_OUTBOUND);
+				mce_async_out(ir, cmdbuf, sizeof(cmdbuf));
 				return carrier;
 			}
 		}
@@ -799,7 +933,6 @@
 {
 	int result;
 	unsigned int ivalue;
-	unsigned long lvalue;
 	struct mceusb_dev *ir = NULL;
 
 	/* Retrieve lirc_driver data for the device */
@@ -828,26 +961,6 @@
 		dprintk(DRIVER_NAME ": SET_TRANSMITTERS mask=%d\n", ivalue);
 		break;
 
-	case LIRC_GET_SEND_MODE:
-
-		result = put_user(LIRC_SEND2MODE(LIRC_CAN_SEND_PULSE &
-						 LIRC_CAN_SEND_MASK),
-				  (unsigned long *) arg);
-
-		if (result)
-			return result;
-		break;
-
-	case LIRC_SET_SEND_MODE:
-
-		result = get_user(lvalue, (unsigned long *) arg);
-
-		if (result)
-			return result;
-		if (lvalue != (LIRC_MODE_PULSE&LIRC_CAN_SEND_MASK))
-			return -EINVAL;
-		break;
-
 	case LIRC_SET_SEND_CARRIER:
 
 		result = get_user(ivalue, (unsigned int *) arg);
@@ -870,45 +983,25 @@
 	.ioctl	= mceusb_lirc_ioctl,
 };
 
-static int mceusb_gen1_init(struct mceusb_dev *ir)
+static void mceusb_gen1_init(struct mceusb_dev *ir)
 {
-	int i, ret;
-	char junk[64], data[8];
-	int partial = 0;
-
-	/*
-	 * Clear off the first few messages. These look like calibration
-	 * or test data, I can't really tell. This also flushes in case
-	 * we have random ir data queued up.
-	 */
-	for (i = 0; i < 40; i++)
-		usb_bulk_msg(ir->usbdev,
-			usb_rcvbulkpipe(ir->usbdev,
-				ir->usb_ep_in->bEndpointAddress),
-			junk, 64, &partial, HZ * 10);
-
-	ir->is_pulse = 1;
-
-	memset(data, 0, 8);
-
-	/* Get Status */
-	ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
-			      USB_REQ_GET_STATUS, USB_DIR_IN,
-			      0, 0, data, 2, HZ * 3);
-
-	/*    ret = usb_get_status( ir->usbdev, 0, 0, data ); */
-	dprintk("%s - ret = %d status = 0x%x 0x%x\n", __func__,
-		ret, data[0], data[1]);
+	int ret;
+	int maxp = ir->len_in;
+	char *data;
+
+	data = kzalloc(USB_CTRL_MSG_SZ, GFP_KERNEL);
+	if (!data) {
+		printk(KERN_ERR "%s: memory allocation failed!\n", __func__);
+		return;
+	}
 
 	/*
 	 * This is a strange one. They issue a set address to the device
 	 * on the receive control pipe and expect a certain value pair back
 	 */
-	memset(data, 0, 8);
-
 	ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
 			      USB_REQ_SET_ADDRESS, USB_TYPE_VENDOR, 0, 0,
-			      data, 2, HZ * 3);
+			      data, USB_CTRL_MSG_SZ, HZ * 3);
 	dprintk("%s - ret = %d, devnum = %d\n",
 		__func__, ret, ir->usbdev->devnum);
 	dprintk("%s - data[0] = %d, data[1] = %d\n",
@@ -933,12 +1026,62 @@
 			      0x0000, 0x0100, NULL, 0, HZ * 3);
 	dprintk("%s - retC = %d\n", __func__, ret);
 
-	return ret;
+	/* device reset */
+	mce_async_out(ir, DEVICE_RESET, sizeof(DEVICE_RESET));
+	mce_sync_in(ir, NULL, maxp);
+
+	/* get hw/sw revision? */
+	mce_async_out(ir, GET_REVISION, sizeof(GET_REVISION));
+	mce_sync_in(ir, NULL, maxp);
+
+	kfree(data);
+
+	return;
 
 };
 
-static int mceusb_dev_probe(struct usb_interface *intf,
-				const struct usb_device_id *id)
+static void mceusb_gen2_init(struct mceusb_dev *ir)
+{
+	int maxp = ir->len_in;
+
+	/* device reset */
+	mce_async_out(ir, DEVICE_RESET, sizeof(DEVICE_RESET));
+	mce_sync_in(ir, NULL, maxp);
+
+	/* get hw/sw revision? */
+	mce_async_out(ir, GET_REVISION, sizeof(GET_REVISION));
+	mce_sync_in(ir, NULL, maxp);
+
+	/* unknown what the next two actually return... */
+	mce_async_out(ir, GET_UNKNOWN, sizeof(GET_UNKNOWN));
+	mce_sync_in(ir, NULL, maxp);
+	mce_async_out(ir, GET_UNKNOWN2, sizeof(GET_UNKNOWN2));
+	mce_sync_in(ir, NULL, maxp);
+}
+
+static void mceusb_get_parameters(struct mceusb_dev *ir)
+{
+	int maxp = ir->len_in;
+
+	/* get the carrier and frequency */
+	mce_async_out(ir, GET_CARRIER_FREQ, sizeof(GET_CARRIER_FREQ));
+	mce_sync_in(ir, NULL, maxp);
+
+	/* get the transmitter bitmask */
+	mce_async_out(ir, GET_TX_BITMASK, sizeof(GET_TX_BITMASK));
+	mce_sync_in(ir, NULL, maxp);
+
+	/* get receiver timeout value */
+	mce_async_out(ir, GET_RX_TIMEOUT, sizeof(GET_RX_TIMEOUT));
+	mce_sync_in(ir, NULL, maxp);
+
+	/* get receiver sensor setting */
+	mce_async_out(ir, GET_RX_SENSOR, sizeof(GET_RX_SENSOR));
+	mce_sync_in(ir, NULL, maxp);
+}
+
+static int __devinit mceusb_dev_probe(struct usb_interface *intf,
+				      const struct usb_device_id *id)
 {
 	struct usb_device *dev = interface_to_usbdev(intf);
 	struct usb_host_interface *idesc;
@@ -954,19 +1097,15 @@
 	int i;
 	char buf[63], name[128] = "";
 	int mem_failure = 0;
-	int is_pinnacle;
-	int is_microsoft_gen1;
+	bool is_gen3;
+	bool is_microsoft_gen1;
 
 	dprintk(DRIVER_NAME ": %s called\n", __func__);
 
-	usb_reset_device(dev);
-
 	config = dev->actconfig;
-
 	idesc = intf->cur_altsetting;
 
-	is_pinnacle = usb_match_id(intf, pinnacle_list) ? 1 : 0;
-
+	is_gen3 = usb_match_id(intf, gen3_list) ? 1 : 0;
 	is_microsoft_gen1 = usb_match_id(intf, microsoft_gen1_list) ? 1 : 0;
 
 	/* step through the endpoints to find first bulk in and out endpoint */
@@ -985,14 +1124,7 @@
 				"found\n");
 			ep_in = ep;
 			ep_in->bmAttributes = USB_ENDPOINT_XFER_INT;
-			if (is_pinnacle)
-				/*
-				 * setting seems to 1 seem to cause issues with
-				 * Pinnacle timing out on transfer.
-				 */
-				ep_in->bInterval = ep->bInterval;
-			else
-				ep_in->bInterval = 1;
+			ep_in->bInterval = 1;
 		}
 
 		if ((ep_out == NULL)
@@ -1007,14 +1139,7 @@
 				"found\n");
 			ep_out = ep;
 			ep_out->bmAttributes = USB_ENDPOINT_XFER_INT;
-			if (is_pinnacle)
-				/*
-				 * setting seems to 1 seem to cause issues with
-				 * Pinnacle timing out on transfer.
-				 */
-				ep_out->bInterval = ep->bInterval;
-			else
-				ep_out->bInterval = 1;
+			ep_out->bInterval = 1;
 		}
 	}
 	if (ep_in == NULL || ep_out == NULL) {
@@ -1029,39 +1154,27 @@
 
 	mem_failure = 0;
 	ir = kzalloc(sizeof(struct mceusb_dev), GFP_KERNEL);
-	if (!ir) {
-		mem_failure = 1;
-		goto mem_failure_switch;
-	}
+	if (!ir)
+		goto mem_alloc_fail;
 
 	driver = kzalloc(sizeof(struct lirc_driver), GFP_KERNEL);
-	if (!driver) {
-		mem_failure = 2;
-		goto mem_failure_switch;
-	}
+	if (!driver)
+		goto mem_alloc_fail;
 
-	rbuf = kmalloc(sizeof(struct lirc_buffer), GFP_KERNEL);
-	if (!rbuf) {
-		mem_failure = 3;
-		goto mem_failure_switch;
-	}
-
-	if (lirc_buffer_init(rbuf, sizeof(lirc_t), LIRCBUF_SIZE)) {
-		mem_failure = 4;
-		goto mem_failure_switch;
-	}
-
-	ir->buf_in = usb_buffer_alloc(dev, maxp, GFP_ATOMIC, &ir->dma_in);
-	if (!ir->buf_in) {
-		mem_failure = 5;
-		goto mem_failure_switch;
-	}
+	rbuf = kzalloc(sizeof(struct lirc_buffer), GFP_KERNEL);
+	if (!rbuf)
+		goto mem_alloc_fail;
+
+	if (lirc_buffer_init(rbuf, sizeof(lirc_t), LIRCBUF_SIZE))
+		goto mem_alloc_fail;
+
+	ir->buf_in = usb_alloc_coherent(dev, maxp, GFP_ATOMIC, &ir->dma_in);
+	if (!ir->buf_in)
+		goto buf_in_alloc_fail;
 
 	ir->urb_in = usb_alloc_urb(0, GFP_KERNEL);
-	if (!ir->urb_in) {
-		mem_failure = 7;
-		goto mem_failure_switch;
-	}
+	if (!ir->urb_in)
+		goto urb_in_alloc_fail;
 
 	strcpy(driver->name, DRIVER_NAME " ");
 	driver->minor = -1;
@@ -1078,33 +1191,12 @@
 	driver->dev   = &intf->dev;
 	driver->owner = THIS_MODULE;
 
-	mutex_init(&ir->lock);
+	mutex_init(&ir->dev_lock);
 	init_waitqueue_head(&ir->wait_out);
 
 	minor = lirc_register_driver(driver);
 	if (minor < 0)
-		mem_failure = 9;
-
-mem_failure_switch:
-
-	switch (mem_failure) {
-	case 9:
-		usb_free_urb(ir->urb_in);
-	case 7:
-		usb_buffer_free(dev, maxp, ir->buf_in, ir->dma_in);
-	case 5:
-		lirc_buffer_free(rbuf);
-	case 4:
-		kfree(rbuf);
-	case 3:
-		kfree(driver);
-	case 2:
-		kfree(ir);
-	case 1:
-		printk(DRIVER_NAME "[%d]: out of memory (code=%d)\n",
-			devnum, mem_failure);
-		return -ENOMEM;
-	}
+		goto lirc_register_fail;
 
 	driver->minor = minor;
 	ir->d = driver;
@@ -1113,7 +1205,6 @@
 	ir->len_in = maxp;
 	ir->overflow_len = 0;
 	ir->flags.connected = 0;
-	ir->flags.pinnacle = is_pinnacle;
 	ir->flags.microsoft_gen1 = is_microsoft_gen1;
 	ir->flags.transmitter_mask_inverted =
 		usb_match_id(intf, transmitter_mask_list) ? 0 : 1;
@@ -1121,8 +1212,6 @@
 	ir->lircdata = PULSE_MASK;
 	ir->is_pulse = 0;
 
-	/* ir->flags.transmitter_mask_inverted must be set */
-	set_transmitter_mask(ir, MCE_DEFAULT_TX_MASK);
 	/* Saving usb interface data for use by the transmitter routine */
 	ir->usb_ep_in = ep_in;
 	ir->usb_ep_out = ep_out;
@@ -1139,73 +1228,49 @@
 	printk(DRIVER_NAME "[%d]: %s on usb%d:%d\n", devnum, name,
 	       dev->bus->busnum, devnum);
 
-	/* inbound data */
+	/* flush buffers on the device */
+	mce_sync_in(ir, NULL, maxp);
+	mce_sync_in(ir, NULL, maxp);
+
+	/* wire up inbound data handler */
 	usb_fill_int_urb(ir->urb_in, dev, pipe, ir->buf_in,
 		maxp, (usb_complete_t) mceusb_dev_recv, ir, ep_in->bInterval);
 	ir->urb_in->transfer_dma = ir->dma_in;
 	ir->urb_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 
 	/* initialize device */
-	if (ir->flags.pinnacle) {
-		int usbret;
-
-		/*
-		 * I have no idea why but this reset seems to be crucial to
-		 * getting the device to do outbound IO correctly - without
-		 * this the device seems to hang, ignoring all input - although
-		 * IR signals are correctly sent from the device, no input is
-		 * interpreted by the device and the host never does the
-		 * completion routine
-		 */
-
-		usbret = usb_reset_configuration(dev);
-		printk(DRIVER_NAME "[%d]: usb reset config ret %x\n",
-		       devnum, usbret);
-
-		/*
-		 * its possible we really should wait for a return
-		 * for each of these...
-		 */
-		request_packet_async(ir, ep_in, NULL, maxp, MCEUSB_INBOUND);
-		request_packet_async(ir, ep_out, pin_init1, sizeof(pin_init1),
-				     MCEUSB_OUTBOUND);
-		request_packet_async(ir, ep_in, NULL, maxp, MCEUSB_INBOUND);
-		request_packet_async(ir, ep_out, pin_init2, sizeof(pin_init2),
-				     MCEUSB_OUTBOUND);
-		request_packet_async(ir, ep_in, NULL, maxp, MCEUSB_INBOUND);
-		request_packet_async(ir, ep_out, pin_init3, sizeof(pin_init3),
-				     MCEUSB_OUTBOUND);
-	} else if (ir->flags.microsoft_gen1) {
-		/* original ms mce device requires some additional setup */
+	if (ir->flags.microsoft_gen1)
 		mceusb_gen1_init(ir);
-	} else {
+	else if (!is_gen3)
+		mceusb_gen2_init(ir);
 
-		request_packet_async(ir, ep_in, NULL, maxp, MCEUSB_INBOUND);
-		request_packet_async(ir, ep_in, NULL, maxp, MCEUSB_INBOUND);
-		request_packet_async(ir, ep_out, init1,
-				     sizeof(init1), MCEUSB_OUTBOUND);
-		request_packet_async(ir, ep_in, NULL, maxp, MCEUSB_INBOUND);
-		request_packet_async(ir, ep_out, init2,
-				     sizeof(init2), MCEUSB_OUTBOUND);
-	}
+	mceusb_get_parameters(ir);
 
-	/*
-	 * if we don't issue the correct number of receives (MCEUSB_INBOUND)
-	 * for each outbound, then the first few ir pulses will be interpreted
-	 * by the usb_async_callback routine - we should ensure we have the
-	 * right amount OR less - as the meusb_dev_recv routine will handle
-	 * the control packets OK - they start with 0x9f - but the async
-	 * callback doesn't handle ir pulse packets
-	 */
-	request_packet_async(ir, ep_in, NULL, maxp, 0);
+	/* ir->flags.transmitter_mask_inverted must be set */
+	set_transmitter_mask(ir, MCE_DEFAULT_TX_MASK);
 
 	usb_set_intfdata(intf, ir);
 
 	return 0;
+
+	/* Error-handling path */
+lirc_register_fail:
+	usb_free_urb(ir->urb_in);
+urb_in_alloc_fail:
+	usb_free_coherent(dev, maxp, ir->buf_in, ir->dma_in);
+buf_in_alloc_fail:
+	lirc_buffer_free(rbuf);
+mem_alloc_fail:
+	kfree(rbuf);
+	kfree(driver);
+	kfree(ir);
+	printk(KERN_ERR "out of memory (code=%d)\n", mem_failure);
+
+	return -ENOMEM;
 }
 
 
-static void mceusb_dev_disconnect(struct usb_interface *intf)
+static void __devexit mceusb_dev_disconnect(struct usb_interface *intf)
 {
 	struct usb_device *dev = interface_to_usbdev(intf);
 	struct mceusb_dev *ir = usb_get_intfdata(intf);
@@ -1218,11 +1283,11 @@
 	ir->usbdev = NULL;
 	wake_up_all(&ir->wait_out);
 
-	mutex_lock(&ir->lock);
+	mutex_lock(&ir->dev_lock);
 	usb_kill_urb(ir->urb_in);
 	usb_free_urb(ir->urb_in);
-	usb_buffer_free(dev, ir->len_in, ir->buf_in, ir->dma_in);
-	mutex_unlock(&ir->lock);
+	usb_free_coherent(dev, ir->len_in, ir->buf_in, ir->dma_in);
+	mutex_unlock(&ir->dev_lock);
 
 	unregister_from_lirc(ir);
 }
--- drivers/lirc_streamzap/lirc_streamzap.c	2010/03/17 14:16:16	1.48
+++ drivers/lirc_streanzap/lirc_streamzap.c	2010/07/25 16:43:33	1.54
@@ -1,4 +1,4 @@
-/*      $Id: lirc_streamzap.c,v 1.48 2009/03/15 09:34:00 lirc Exp $      */
+/*      $Id: lirc_streamzap.c,v 1.54 2010/07/25 16:43:33 jarodwilson Exp $      */
 /*
  * Streamzap Remote Control driver
  *
@@ -54,7 +56,7 @@
 #include "drivers/kcompat.h"
 #include "drivers/lirc_dev/lirc_dev.h"
 
-#define DRIVER_VERSION	"$Revision: 1.48 $"
+#define DRIVER_VERSION	"$Revision: 1.54 $"
 #define DRIVER_NAME	"lirc_streamzap"
 #define DRIVER_DESC	"Streamzap Remote Control driver"
 
@@ -83,10 +85,11 @@
 
 #define STREAMZAP_PULSE_MASK 0xf0
 #define STREAMZAP_SPACE_MASK 0x0f
+#define STREAMZAP_TIMEOUT    0xff
 #define STREAMZAP_RESOLUTION 256
 
 /* number of samples buffered */
-#define STREAMZAP_BUFFER_SIZE 128
+#define STREAMZAP_BUFFER_SIZE 256
 
 enum StreamzapDecoderState {
 	PulseSpace,
@@ -154,6 +157,7 @@
 	struct timer_list	flush_timer;
 	int			flush;
 	int			in_use;
+	int			timeout_enabled;
 };
 
 
@@ -317,12 +321,14 @@
 
 		deltv = sz->signal_start.tv_sec-sz->signal_last.tv_sec;
 		if (deltv > 15) {
-			tmp = PULSE_MASK; /* really long time */
+			/* really long time */
+			tmp = LIRC_SPACE(LIRC_VALUE_MASK);
 		} else {
 			tmp = (lirc_t) (deltv*1000000+
 					sz->signal_start.tv_usec -
 					sz->signal_last.tv_usec);
 			tmp -= sz->sum;
+			tmp = LIRC_SPACE(tmp);
 		}
 		dprintk("ls %u", sz->driver.minor, tmp);
 		push(sz, (char *)&tmp);
@@ -334,7 +340,7 @@
 	pulse = ((lirc_t) value)*STREAMZAP_RESOLUTION;
 	pulse += STREAMZAP_RESOLUTION/2;
 	sz->sum += pulse;
-	pulse |= PULSE_BIT;
+	pulse =  LIRC_PULSE(pulse);
 
 	dprintk("p %u", sz->driver.minor, pulse&PULSE_MASK);
 	push(sz, (char *)&pulse);
@@ -354,6 +360,7 @@
 	space = ((lirc_t) value)*STREAMZAP_RESOLUTION;
 	space += STREAMZAP_RESOLUTION/2;
 	sz->sum += space;
+	space = LIRC_SPACE(space);
 	dprintk("s %u", sz->driver.minor, space);
 	push(sz, (char *)&space);
 }
@@ -426,9 +433,16 @@
 				sz->decoder_state = IgnorePulse;
 				break;
 			case FullSpace:
-				if (sz->buf_in[i] == 0xff) {
+				if (sz->buf_in[i] == STREAMZAP_TIMEOUT) {
 					sz->idle = 1;
 					stop_timer(sz);
+					if (sz->timeout_enabled) {
+						lirc_t timeout =
+							LIRC_TIMEOUT
+							(STREAMZAP_TIMEOUT *
+							 STREAMZAP_RESOLUTION);
+						push(sz, (char *)&timeout);
+					}
 					flush_delay_buffer(sz);
 				} else
 					push_full_space(sz, sz->buf_in[i]);
@@ -546,8 +560,8 @@
 
 	sz->buf_in_len = sz->endpoint->wMaxPacketSize;
 #ifdef KERNEL_2_5
-	sz->buf_in = usb_buffer_alloc(sz->udev, sz->buf_in_len,
-				      GFP_ATOMIC, &sz->dma_in);
+	sz->buf_in = usb_alloc_coherent(sz->udev, sz->buf_in_len,
+					GFP_ATOMIC, &sz->dma_in);
 #else
 	sz->buf_in = kmalloc(sz->buf_in_len, GFP_KERNEL);
 #endif
@@ -579,8 +593,12 @@
 	sz->driver.minor = -1;
 	sz->driver.sample_rate = 0;
 	sz->driver.code_length = sizeof(lirc_t) * 8;
-	sz->driver.features = LIRC_CAN_REC_MODE2 | LIRC_CAN_GET_REC_RESOLUTION;
+	sz->driver.features = LIRC_CAN_REC_MODE2 |
+		LIRC_CAN_GET_REC_RESOLUTION |
+		LIRC_CAN_SET_REC_TIMEOUT;
 	sz->driver.data = sz;
+	sz->driver.min_timeout = STREAMZAP_TIMEOUT * STREAMZAP_RESOLUTION;
+	sz->driver.max_timeout = STREAMZAP_TIMEOUT * STREAMZAP_RESOLUTION;
 	sz->driver.rbuf = &sz->lirc_buf;
 	sz->driver.set_use_inc = &streamzap_use_inc;
 	sz->driver.set_use_dec = &streamzap_use_dec;
@@ -657,7 +675,7 @@
 	if (sz) {
 		usb_free_urb(sz->urb_in);
 #ifdef KERNEL_2_5
-		usb_buffer_free(udev, sz->buf_in_len, sz->buf_in, sz->dma_in);
+		usb_free_coherent(udev, sz->buf_in_len, sz->buf_in, sz->dma_in);
 #else
 		if (sz->buf_in) {
 			kfree(sz->buf_in);
@@ -691,6 +709,8 @@
 	sz->flush = 1;
 	add_timer(&sz->flush_timer);
 
+	sz->timeout_enabled = 0;
+
 	sz->urb_in->dev = sz->udev;
 #ifdef KERNEL_2_5
 	if (usb_submit_urb(sz->urb_in, GFP_ATOMIC)) {
@@ -733,18 +753,35 @@
 static int streamzap_ioctl(struct inode *node, struct file *filep,
 			   unsigned int cmd, unsigned long arg)
 {
-	int result;
+	int result = 0;
+	lirc_t val;
+	unsigned int flag = 0;
+	struct usb_streamzap *sz = lirc_get_pdata(filep);
 
 	switch (cmd) {
 	case LIRC_GET_REC_RESOLUTION:
 		result = put_user(STREAMZAP_RESOLUTION, (unsigned int *) arg);
-		if (result)
-			return result;
+		break;
+	case LIRC_SET_REC_TIMEOUT:
+		result = get_user(val, (lirc_t *)arg);
+		if (result == 0) {
+			if (val != STREAMZAP_TIMEOUT * STREAMZAP_RESOLUTION)
+				result = -EINVAL;
+		}
+		break;
+	case LIRC_SET_REC_TIMEOUT_REPORTS:
+		result = get_user(flag, (unsigned int *)arg);
+		if (result == 0) {
+			if (flag != 0)
+				sz->timeout_enabled = 1;
+			else
+				sz->timeout_enabled = 0;
+		}
 		break;
 	default:
 		return -ENOIOCTLCMD;
 	}
-	return 0;
+	return result;
 }
 
 /**
@@ -788,7 +825,7 @@
 	usb_free_urb(sz->urb_in);
 
 #ifdef KERNEL_2_5
-	usb_buffer_free(sz->udev, sz->buf_in_len, sz->buf_in, sz->dma_in);
+	usb_free_coherent(sz->udev, sz->buf_in_len, sz->buf_in, sz->dma_in);
 #else
 	kfree(sz->buf_in);
 #endif
--- drivers/lirc.h	2009/08/29 07:52:41	5.19
+++ drivers/lirc.h	2010/05/13 15:45:48	5.27
@@ -1,4 +1,4 @@
-/*      $Id: lirc.h,v 5.19 2009/08/29 07:52:41 lirc Exp $      */
+/*      $Id: lirc.h,v 5.27 2010/05/13 15:45:48 lirc Exp $      */
 
 #ifndef _LINUX_LIRC_H
 #define _LINUX_LIRC_H
@@ -12,8 +12,31 @@
 #include <sys/ioctl.h>
 #endif
 
-#define PULSE_BIT  0x01000000
-#define PULSE_MASK 0x00FFFFFF
+/* <obsolete> */
+#define PULSE_BIT       0x01000000
+#define PULSE_MASK      0x00FFFFFF
+/* </obsolete> */
+
+#define LIRC_MODE2_SPACE     0x00000000
+#define LIRC_MODE2_PULSE     0x01000000
+#define LIRC_MODE2_FREQUENCY 0x02000000
+#define LIRC_MODE2_TIMEOUT   0x03000000
+
+#define LIRC_VALUE_MASK      0x00FFFFFF
+#define LIRC_MODE2_MASK      0xFF000000
+
+#define LIRC_SPACE(val) (((val)&LIRC_VALUE_MASK) | LIRC_MODE2_SPACE)
+#define LIRC_PULSE(val) (((val)&LIRC_VALUE_MASK) | LIRC_MODE2_PULSE)
+#define LIRC_FREQUENCY(val) (((val)&LIRC_VALUE_MASK) | LIRC_MODE2_FREQUENCY)
+#define LIRC_TIMEOUT(val) (((val)&LIRC_VALUE_MASK) | LIRC_MODE2_TIMEOUT)
+
+#define LIRC_VALUE(val) ((val)&LIRC_VALUE_MASK)
+#define LIRC_MODE2(val) ((val)&LIRC_MODE2_MASK)
+
+#define LIRC_IS_SPACE(val) (LIRC_MODE2(val) == LIRC_MODE2_SPACE)
+#define LIRC_IS_PULSE(val) (LIRC_MODE2(val) == LIRC_MODE2_PULSE)
+#define LIRC_IS_FREQUENCY(val) (LIRC_MODE2(val) == LIRC_MODE2_FREQUENCY)
+#define LIRC_IS_TIMEOUT(val) (LIRC_MODE2(val) == LIRC_MODE2_TIMEOUT)
 
 typedef int lirc_t;
 
@@ -27,17 +50,17 @@
 #define LIRC_MODE_RAW                  0x00000001
 #define LIRC_MODE_PULSE                0x00000002
 #define LIRC_MODE_MODE2                0x00000004
-#define LIRC_MODE_CODE                 0x00000008
+/* obsolete: #define LIRC_MODE_CODE                 0x00000008 */
 #define LIRC_MODE_LIRCCODE             0x00000010
-#define LIRC_MODE_STRING               0x00000020
+/* obsolete: #define LIRC_MODE_STRING               0x00000020 */
 
 
 #define LIRC_CAN_SEND_RAW              LIRC_MODE2SEND(LIRC_MODE_RAW)
 #define LIRC_CAN_SEND_PULSE            LIRC_MODE2SEND(LIRC_MODE_PULSE)
 #define LIRC_CAN_SEND_MODE2            LIRC_MODE2SEND(LIRC_MODE_MODE2)
-#define LIRC_CAN_SEND_CODE             LIRC_MODE2SEND(LIRC_MODE_CODE)
+/* obsolete: #define LIRC_CAN_SEND_CODE             LIRC_MODE2SEND(LIRC_MODE_CODE) */
 #define LIRC_CAN_SEND_LIRCCODE         LIRC_MODE2SEND(LIRC_MODE_LIRCCODE)
-#define LIRC_CAN_SEND_STRING           LIRC_MODE2SEND(LIRC_MODE_STRING)
+/* obsolete: #define LIRC_CAN_SEND_STRING           LIRC_MODE2SEND(LIRC_MODE_STRING) */
 
 #define LIRC_CAN_SEND_MASK             0x0000003f
 
@@ -48,9 +71,9 @@
 #define LIRC_CAN_REC_RAW               LIRC_MODE2REC(LIRC_MODE_RAW)
 #define LIRC_CAN_REC_PULSE             LIRC_MODE2REC(LIRC_MODE_PULSE)
 #define LIRC_CAN_REC_MODE2             LIRC_MODE2REC(LIRC_MODE_MODE2)
-#define LIRC_CAN_REC_CODE              LIRC_MODE2REC(LIRC_MODE_CODE)
+/* obsolete: #define LIRC_CAN_REC_CODE              LIRC_MODE2REC(LIRC_MODE_CODE) */
 #define LIRC_CAN_REC_LIRCCODE          LIRC_MODE2REC(LIRC_MODE_LIRCCODE)
-#define LIRC_CAN_REC_STRING            LIRC_MODE2REC(LIRC_MODE_STRING)
+/* obsolete: #define LIRC_CAN_REC_STRING            LIRC_MODE2REC(LIRC_MODE_STRING) */
 
 #define LIRC_CAN_REC_MASK              LIRC_MODE2REC(LIRC_CAN_SEND_MASK)
 
@@ -60,6 +83,10 @@
 #define LIRC_CAN_SET_REC_DUTY_CYCLE_RANGE 0x40000000
 #define LIRC_CAN_SET_REC_CARRIER_RANGE    0x80000000
 #define LIRC_CAN_GET_REC_RESOLUTION       0x20000000
+#define LIRC_CAN_SET_REC_TIMEOUT          0x10000000
+#define LIRC_CAN_SET_REC_FILTER           0x08000000
+
+#define LIRC_CAN_MEASURE_CARRIER          0x02000000
 
 #define LIRC_CAN_SEND(x) ((x)&LIRC_CAN_SEND_MASK)
 #define LIRC_CAN_REC(x) ((x)&LIRC_CAN_REC_MASK)
@@ -78,10 +105,23 @@
 #define LIRC_GET_REC_DUTY_CYCLE        _IOR('i', 0x00000006, unsigned int)
 #define LIRC_GET_REC_RESOLUTION        _IOR('i', 0x00000007, unsigned int)
 
+#define LIRC_GET_MIN_TIMEOUT           _IOR('i', 0x00000008, lirc_t)
+#define LIRC_GET_MAX_TIMEOUT           _IOR('i', 0x00000009, lirc_t)
+
+#define LIRC_GET_MIN_FILTER_PULSE      _IOR('i', 0x0000000a, lirc_t)
+#define LIRC_GET_MAX_FILTER_PULSE      _IOR('i', 0x0000000b, lirc_t)
+#define LIRC_GET_MIN_FILTER_SPACE      _IOR('i', 0x0000000c, lirc_t)
+#define LIRC_GET_MAX_FILTER_SPACE      _IOR('i', 0x0000000d, lirc_t)
+
 /* code length in bits, currently only for LIRC_MODE_LIRCCODE */
 #define LIRC_GET_LENGTH                _IOR('i', 0x0000000f, unsigned long)
 
+/* all values set should be reset by the driver when the device is
+   reopened */
+
+/* obsolete: drivers only support one mode */
 #define LIRC_SET_SEND_MODE             _IOW('i', 0x00000011, unsigned long)
+/* obsolete: drivers only support one mode */
 #define LIRC_SET_REC_MODE              _IOW('i', 0x00000012, unsigned long)
 /* Note: these can reset the according pulse_width */
 #define LIRC_SET_SEND_CARRIER          _IOW('i', 0x00000013, unsigned int)
@@ -90,6 +130,26 @@
 #define LIRC_SET_REC_DUTY_CYCLE        _IOW('i', 0x00000016, unsigned int)
 #define LIRC_SET_TRANSMITTER_MASK      _IOW('i', 0x00000017, unsigned int)
 
+/* a value of 0 disables all hardware timeouts and data should be
+   reported as soon as possible */
+#define LIRC_SET_REC_TIMEOUT           _IOW('i', 0x00000018, lirc_t)
+/* 1 enables, 0 disables timeout reports in MODE2 */
+#define LIRC_SET_REC_TIMEOUT_REPORTS   _IOW('i', 0x00000019, unsigned int)
+
+/* pulses shorter than this are filtered out by hardware (software
+   emulation in lirc_dev/lircd?) */
+#define LIRC_SET_REC_FILTER_PULSE      _IOW('i', 0x0000001a, lirc_t)
+/* spaces shorter than this are filtered out by hardware (software
+   emulation in lirc_dev/lircd?) */
+#define LIRC_SET_REC_FILTER_SPACE      _IOW('i', 0x0000001b, lirc_t)
+/* if filter cannot be set independently for pulse/space, this should
+   be used */
+#define LIRC_SET_REC_FILTER            _IOW('i', 0x0000001c, lirc_t)
+
+/* if enabled from the next key press on the driver will send
+   LIRC_MODE2_FREQUENCY packets */
+#define LIRC_SET_MEASURE_CARRIER_MODE  _IOW('i', 0x0000001d, unsigned int)
+
 /*
  * to set a range use
  * LIRC_SET_REC_DUTY_CYCLE_RANGE/LIRC_SET_REC_CARRIER_RANGE with the
@@ -102,4 +162,7 @@
 
 #define LIRC_NOTIFY_DECODE             _IO('i', 0x00000020)
 
+#define LIRC_SETUP_START               _IO('i', 0x00000021)
+#define LIRC_SETUP_END                 _IO('i', 0x00000022)
+
 #endif
--- drivers/lirc_dev/lirc_dev.c	2009/08/31 16:57:55	1.96
+++ drivers/lirc_dev/lirc_dev.c	2010/05/13 15:45:48	1.105
@@ -17,7 +17,7 @@
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
- * $Id: lirc_dev.c,v 1.96 2009/08/31 16:57:55 lirc Exp $
+ * $Id: lirc_dev.c,v 1.105 2010/05/13 15:45:48 lirc Exp $
  *
  */
 
@@ -367,8 +369,7 @@
 	ir->chunk_size = ir->buf->chunk_size;
 
 	if (d->features == 0)
-		d->features = (d->code_length > 8) ?
-			LIRC_CAN_REC_LIRCCODE : LIRC_CAN_REC_CODE;
+		d->features = LIRC_CAN_REC_LIRCCODE;
 
 	ir->d = *d;
 	ir->d.minor = minor;
@@ -541,7 +542,7 @@
 static int irctl_open(struct inode *inode, struct file *file)
 {
 	struct irctl *ir;
-	int retval;
+	int retval = 0;
 
 	if (iminor(inode) >= MAX_IRCTL_DEVICES || !irctls[iminor(inode)]) {
 		dprintk("lirc_dev [%d]: open result = -ENODEV\n",
@@ -591,6 +592,8 @@
 		if (ir->task)
 			wake_up_process(ir->task);
 #endif
+	} else {
+		retval = -ENODEV;
 	}
  error:
 	if (ir)
@@ -692,6 +695,23 @@
 	case LIRC_GET_FEATURES:
 		result = put_user(ir->d.features, (unsigned long *)arg);
 		break;
+	case LIRC_GET_LENGTH:
+		result = put_user(ir->d.code_length, (unsigned long *) arg);
+		break;
+	case LIRC_GET_MIN_TIMEOUT:
+		if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) ||
+		    ir->d.min_timeout == 0)
+			return -ENOSYS;
+
+		result = put_user(ir->d.min_timeout, (lirc_t *) arg);
+		break;
+	case LIRC_GET_MAX_TIMEOUT:
+		if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) ||
+		    ir->d.max_timeout == 0)
+			return -ENOSYS;
+
+		result = put_user(ir->d.max_timeout, (lirc_t *) arg);
+		break;
 	case LIRC_GET_REC_MODE:
 		if (!(ir->d.features & LIRC_CAN_REC_MASK))
 			return -ENOSYS;
@@ -700,6 +720,16 @@
 				  (ir->d.features & LIRC_CAN_REC_MASK),
 				  (unsigned long *)arg);
 		break;
+	case LIRC_GET_SEND_MODE:
+		if (!(ir->d.features & LIRC_CAN_SEND_MASK))
+			return -ENOSYS;
+
+		result = put_user(LIRC_SEND2MODE
+				  (ir->d.features & LIRC_CAN_SEND_MASK),
+				  (unsigned long *)arg);
+		break;
+
+	/*obsolete */
 	case LIRC_SET_REC_MODE:
 		if (!(ir->d.features & LIRC_CAN_REC_MASK))
 			return -ENOSYS;
@@ -707,18 +737,30 @@
 		result = get_user(mode, (unsigned long *)arg);
 		if (!result && !(LIRC_MODE2REC(mode) & ir->d.features))
 			result = -EINVAL;
-		/*
-		 * FIXME: We should actually set the mode somehow but
-		 * for now, lirc_serial doesn't support mode changing either
-		 */
 		break;
-	case LIRC_GET_LENGTH:
-		result = put_user(ir->d.code_length, (unsigned long *) arg);
+	case LIRC_SET_SEND_MODE:
+		if (!(ir->d.features & LIRC_CAN_SEND_MASK))
+			return -ENOSYS;
+
+		result = get_user(mode, (unsigned long *)arg);
+		if (!result && !(LIRC_MODE2SEND(mode) & ir->d.features))
+			result = -EINVAL;
 		break;
 	default:
 		result = -EINVAL;
 	}
 
+	switch (cmd) {
+	case LIRC_SET_REC_MODE:
+	case LIRC_SET_SEND_MODE:
+		printk(KERN_NOTICE LOGHEAD "userspace uses outdated ioctl "
+			"please update your lirc installation\n",
+			ir->d.name, ir->d.minor);
+		break;
+	default:
+		break;
+	}
+
 	dprintk(LOGHEAD "ioctl result = %d\n",
 		ir->d.name, ir->d.minor, result);
 
@@ -791,16 +833,31 @@
 	case LIRC_GET_SEND_DUTY_CYCLE:
 	case LIRC_GET_REC_DUTY_CYCLE:
 	case LIRC_GET_REC_RESOLUTION:
+	case LIRC_GET_MIN_TIMEOUT:
+	case LIRC_GET_MAX_TIMEOUT:
+	case LIRC_GET_MIN_FILTER_PULSE:
+	case LIRC_GET_MAX_FILTER_PULSE:
+	case LIRC_GET_MIN_FILTER_SPACE:
+	case LIRC_GET_MAX_FILTER_SPACE:
 	case LIRC_SET_SEND_CARRIER:
 	case LIRC_SET_REC_CARRIER:
 	case LIRC_SET_SEND_DUTY_CYCLE:
 	case LIRC_SET_REC_DUTY_CYCLE:
 	case LIRC_SET_TRANSMITTER_MASK:
+	case LIRC_SET_REC_TIMEOUT:
+	case LIRC_SET_REC_TIMEOUT_REPORTS:
+	case LIRC_SET_REC_FILTER_PULSE:
+	case LIRC_SET_REC_FILTER_SPACE:
+	case LIRC_SET_REC_FILTER:
+	case LIRC_SET_MEASURE_CARRIER_MODE:
 	case LIRC_SET_REC_DUTY_CYCLE_RANGE:
 	case LIRC_SET_REC_CARRIER_RANGE:
+	case LIRC_NOTIFY_DECODE:
+	case LIRC_SETUP_START:
+	case LIRC_SETUP_END:
 		/*
-		 * These commands expect (unsigned int *)arg
-		 * so no problems here. Just handle the locking.
+		 * These commands expect (unsigned int *) or (lirc_t *)
+		 * arg so no problems here. Just handle the locking.
 		 */
 		lock_kernel();
 		cmd = cmd32;
--- drivers/lirc_dev/lirc_dev.h	2009/12/28 15:21:17	1.38
+++ drivers/lirc_dev/lirc_dev.h	2010/04/25 08:33:52	1.41
@@ -4,7 +4,7 @@
  * (L) by Artur Lipowski <alipowski@interia.pl>
  *        This code is licensed under GNU GPL
  *
- * $Id: lirc_dev.h,v 1.38 2009/12/28 15:21:17 jarodwilson Exp $
+ * $Id: lirc_dev.h,v 1.41 2010/04/25 08:33:52 lirc Exp $
  *
  */
 
@@ -28,6 +28,8 @@
 #include <linux/kfifo.h>
 #endif
 
+#include "drivers/lirc.h"
+
 struct lirc_buffer {
 	wait_queue_head_t wait_poll;
 	spinlock_t fifo_lock;
@@ -68,13 +70,13 @@
 #endif
 static inline void lirc_buffer_clear(struct lirc_buffer *buf)
 {
-	unsigned long flags;
-
 #ifdef LIRC_HAVE_KFIFO
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)
 	if (buf->fifo)
 		kfifo_reset(buf->fifo);
 #else
+	unsigned long flags;
+
 	if (buf->fifo_initialized) {
 		spin_lock_irqsave(&buf->fifo_lock, flags);
 		kfifo_reset(&buf->fifo);
@@ -82,6 +84,8 @@
 	}
 #endif
 #else
+	unsigned long flags;
+
 	lirc_buffer_lock(buf, &flags);
 	_lirc_buffer_clear(buf);
 	lirc_buffer_unlock(buf, &flags);
@@ -331,6 +335,8 @@
 	int sample_rate;
 	unsigned long features;
 	void *data;
+	lirc_t min_timeout;
+	lirc_t max_timeout;
 	int (*add_to_buf) (void *data, struct lirc_buffer *buf);
 #ifndef LIRC_REMOVE_DURING_EXPORT
 	wait_queue_head_t* (*get_queue) (void *data);
@@ -338,7 +344,7 @@
 	struct lirc_buffer *rbuf;
 	int (*set_use_inc) (void *data);
 	void (*set_use_dec) (void *data);
-	struct file_operations *fops;
+	const struct file_operations *fops;
 	struct device *dev;
 	struct module *owner;
 };