Merge branch 'master' into for-next

Sync with Linus' tree to be able to apply pending patches that
are based on newer code already present upstream.

11 files changed, 154 insertions, 115 deletions

diff --git a/drivers/media/rc/fintek-cir.c b/drivers/media/rc/fintek-cir.c
index 8fa539dde1b4..7f7079b12f23 100644
--- a/drivers/media/rc/fintek-cir.c
+++ b/drivers/media/rc/fintek-cir.c
@@ -597,12 +597,17 @@ static void __devexit fintek_remove(struct pnp_dev *pdev)
 static int fintek_suspend(struct pnp_dev *pdev, pm_message_t state)
 {
         struct fintek_dev *fintek = pnp_get_drvdata(pdev);
+        unsigned long flags;
 
         fit_dbg("%s called", __func__);
 
+        spin_lock_irqsave(&fintek->fintek_lock, flags);
+
         /* disable all CIR interrupts */
         fintek_cir_reg_write(fintek, CIR_STATUS_IRQ_MASK, CIR_STATUS);
 
+        spin_unlock_irqrestore(&fintek->fintek_lock, flags);
+
         fintek_config_mode_enable(fintek);
 
         /* disable cir logical dev */
diff --git a/drivers/media/rc/imon.c b/drivers/media/rc/imon.c
index 3f3c70716268..6bc35eeb653b 100644
--- a/drivers/media/rc/imon.c
+++ b/drivers/media/rc/imon.c
@@ -307,6 +307,14 @@ static const struct {
         /* 0xffdc iMON MCE VFD */
         { 0x00010000ffffffeell, KEY_VOLUMEUP },
         { 0x01000000ffffffeell, KEY_VOLUMEDOWN },
+        { 0x00000001ffffffeell, KEY_MUTE },
+        { 0x0000000fffffffeell, KEY_MEDIA },
+        { 0x00000012ffffffeell, KEY_UP },
+        { 0x00000013ffffffeell, KEY_DOWN },
+        { 0x00000014ffffffeell, KEY_LEFT },
+        { 0x00000015ffffffeell, KEY_RIGHT },
+        { 0x00000016ffffffeell, KEY_ENTER },
+        { 0x00000017ffffffeell, KEY_ESC },
         /* iMON Knob values */
         { 0x000100ffffffffeell, KEY_VOLUMEUP },
         { 0x010000ffffffffeell, KEY_VOLUMEDOWN },
@@ -1582,16 +1590,16 @@ static void imon_incoming_packet(struct imon_context *ictx,
         /* Only panel type events left to process now */
         spin_lock_irqsave(&ictx->kc_lock, flags);
 
+        do_gettimeofday(&t);
         /* KEY_MUTE repeats from knob need to be suppressed */
         if (ictx->kc == KEY_MUTE && ictx->kc == ictx->last_keycode) {
-                do_gettimeofday(&t);
                 msec = tv2int(&t, &prev_time);
-                prev_time = t;
                 if (msec < ictx->idev->rep[REP_DELAY]) {
                         spin_unlock_irqrestore(&ictx->kc_lock, flags);
                         return;
                 }
         }
+        prev_time = t;
         kc = ictx->kc;
 
         spin_unlock_irqrestore(&ictx->kc_lock, flags);
@@ -1603,7 +1611,9 @@ static void imon_incoming_packet(struct imon_context *ictx,
         input_report_key(ictx->idev, kc, 0);
         input_sync(ictx->idev);
 
+        spin_lock_irqsave(&ictx->kc_lock, flags);
         ictx->last_keycode = kc;
+        spin_unlock_irqrestore(&ictx->kc_lock, flags);
 
         return;
 
@@ -1740,6 +1750,8 @@ static void imon_get_ffdc_type(struct imon_context *ictx)
                 detected_display_type = IMON_DISPLAY_TYPE_VFD;
                 break;
         /* iMON VFD, MCE IR */
+        case 0x46:
+        case 0x7e:
         case 0x9e:
                 dev_info(ictx->dev, "0xffdc iMON VFD, MCE IR");
                 detected_display_type = IMON_DISPLAY_TYPE_VFD;
@@ -1755,6 +1767,9 @@ static void imon_get_ffdc_type(struct imon_context *ictx)
                 dev_info(ictx->dev, "Unknown 0xffdc device, "
                          "defaulting to VFD and iMON IR");
                 detected_display_type = IMON_DISPLAY_TYPE_VFD;
+                /* We don't know which one it is, allow user to set the
+                 * RC6 one from userspace if OTHER wasn't correct. */
+                allowed_protos |= RC_TYPE_RC6;
                 break;
         }
 
diff --git a/drivers/media/rc/ir-raw.c b/drivers/media/rc/ir-raw.c
index 11c19d8d0ee0..423ed45d6c55 100644
--- a/drivers/media/rc/ir-raw.c
+++ b/drivers/media/rc/ir-raw.c
@@ -114,18 +114,20 @@ int ir_raw_event_store_edge(struct rc_dev *dev, enum raw_event_type type)
         s64                     delta; /* ns */
         DEFINE_IR_RAW_EVENT(ev);
         int                     rc = 0;
+        int                     delay;
 
         if (!dev->raw)
                 return -EINVAL;
 
         now = ktime_get();
         delta = ktime_to_ns(ktime_sub(now, dev->raw->last_event));
+        delay = MS_TO_NS(dev->input_dev->rep[REP_DELAY]);
 
         /* Check for a long duration since last event or if we're
          * being called for the first time, note that delta can't
          * possibly be negative.
          */
-        if (delta > IR_MAX_DURATION || !dev->raw->last_type)
+        if (delta > delay || !dev->raw->last_type)
                 type |= IR_START_EVENT;
         else
                 ev.duration = delta;
diff --git a/drivers/media/rc/ite-cir.c b/drivers/media/rc/ite-cir.c
index cd0c44e398e3..d20168fe4c40 100644
--- a/drivers/media/rc/ite-cir.c
+++ b/drivers/media/rc/ite-cir.c
@@ -1346,6 +1346,7 @@ static const struct ite_dev_params ite_dev_descs[] = {
         {       /* 0: ITE8704 */
                .model = "ITE8704 CIR transceiver",
                .io_region_size = IT87_IOREG_LENGTH,
+               .io_rsrc_no = 0,
                .hw_tx_capable = true,
                .sample_period = (u32) (1000000000ULL / 115200),
                .tx_carrier_freq = 38000,
@@ -1370,6 +1371,7 @@ static const struct ite_dev_params ite_dev_descs[] = {
         {       /* 1: ITE8713 */
                .model = "ITE8713 CIR transceiver",
                .io_region_size = IT87_IOREG_LENGTH,
+               .io_rsrc_no = 0,
                .hw_tx_capable = true,
                .sample_period = (u32) (1000000000ULL / 115200),
                .tx_carrier_freq = 38000,
@@ -1394,6 +1396,7 @@ static const struct ite_dev_params ite_dev_descs[] = {
         {       /* 2: ITE8708 */
                .model = "ITE8708 CIR transceiver",
                .io_region_size = IT8708_IOREG_LENGTH,
+               .io_rsrc_no = 0,
                .hw_tx_capable = true,
                .sample_period = (u32) (1000000000ULL / 115200),
                .tx_carrier_freq = 38000,
@@ -1419,6 +1422,7 @@ static const struct ite_dev_params ite_dev_descs[] = {
         {       /* 3: ITE8709 */
                .model = "ITE8709 CIR transceiver",
                .io_region_size = IT8709_IOREG_LENGTH,
+               .io_rsrc_no = 2,
                .hw_tx_capable = true,
                .sample_period = (u32) (1000000000ULL / 115200),
                .tx_carrier_freq = 38000,
@@ -1460,6 +1464,7 @@ static int ite_probe(struct pnp_dev *pdev, const struct pnp_device_id
         struct rc_dev *rdev = NULL;
         int ret = -ENOMEM;
         int model_no;
+        int io_rsrc_no;
 
         ite_dbg("%s called", __func__);
 
@@ -1489,10 +1494,11 @@ static int ite_probe(struct pnp_dev *pdev, const struct pnp_device_id
 
         /* get the description for the device */
         dev_desc = &ite_dev_descs[model_no];
+        io_rsrc_no = dev_desc->io_rsrc_no;
 
         /* validate pnp resources */
-        if (!pnp_port_valid(pdev, 0) ||
-            pnp_port_len(pdev, 0) != dev_desc->io_region_size) {
+        if (!pnp_port_valid(pdev, io_rsrc_no) ||
+            pnp_port_len(pdev, io_rsrc_no) != dev_desc->io_region_size) {
                 dev_err(&pdev->dev, "IR PNP Port not valid!\n");
                 goto failure;
         }
@@ -1503,7 +1509,7 @@ static int ite_probe(struct pnp_dev *pdev, const struct pnp_device_id
         }
 
         /* store resource values */
-        itdev->cir_addr = pnp_port_start(pdev, 0);
+        itdev->cir_addr = pnp_port_start(pdev, io_rsrc_no);
         itdev->cir_irq = pnp_irq(pdev, 0);
 
         /* initialize spinlocks */
diff --git a/drivers/media/rc/ite-cir.h b/drivers/media/rc/ite-cir.h
index 16a19f5fd718..aa899a0b9750 100644
--- a/drivers/media/rc/ite-cir.h
+++ b/drivers/media/rc/ite-cir.h
@@ -57,6 +57,9 @@ struct ite_dev_params {
         /* size of the I/O region */
         int io_region_size;
 
+        /* IR pnp I/O resource number */
+        int io_rsrc_no;
+
         /* true if the hardware supports transmission */
         bool hw_tx_capable;
 
diff --git a/drivers/media/rc/keymaps/rc-pinnacle-pctv-hd.c b/drivers/media/rc/keymaps/rc-pinnacle-pctv-hd.c
index bb10ffe086b4..8d558ae63456 100644
--- a/drivers/media/rc/keymaps/rc-pinnacle-pctv-hd.c
+++ b/drivers/media/rc/keymaps/rc-pinnacle-pctv-hd.c
@@ -15,43 +15,39 @@
 /* Pinnacle PCTV HD 800i mini remote */
 
 static struct rc_map_table pinnacle_pctv_hd[] = {
-
-        { 0x0f, KEY_1 },
-        { 0x15, KEY_2 },
-        { 0x10, KEY_3 },
-        { 0x18, KEY_4 },
-        { 0x1b, KEY_5 },
-        { 0x1e, KEY_6 },
-        { 0x11, KEY_7 },
-        { 0x21, KEY_8 },
-        { 0x12, KEY_9 },
-        { 0x27, KEY_0 },
-
-        { 0x24, KEY_ZOOM },
-        { 0x2a, KEY_SUBTITLE },
-
-        { 0x00, KEY_MUTE },
-        { 0x01, KEY_ENTER },    /* Pinnacle Logo */
-        { 0x39, KEY_POWER },
-
-        { 0x03, KEY_VOLUMEUP },
-        { 0x09, KEY_VOLUMEDOWN },
-        { 0x06, KEY_CHANNELUP },
-        { 0x0c, KEY_CHANNELDOWN },
-
-        { 0x2d, KEY_REWIND },
-        { 0x30, KEY_PLAYPAUSE },
-        { 0x33, KEY_FASTFORWARD },
-        { 0x3c, KEY_STOP },
-        { 0x36, KEY_RECORD },
-        { 0x3f, KEY_EPG },      /* Labeled "?" */
+        /* Key codes for the tiny Pinnacle remote*/
+        { 0x0700, KEY_MUTE },
+        { 0x0701, KEY_MENU }, /* Pinnacle logo */
+        { 0x0739, KEY_POWER },
+        { 0x0703, KEY_VOLUMEUP },
+        { 0x0709, KEY_VOLUMEDOWN },
+        { 0x0706, KEY_CHANNELUP },
+        { 0x070c, KEY_CHANNELDOWN },
+        { 0x070f, KEY_1 },
+        { 0x0715, KEY_2 },
+        { 0x0710, KEY_3 },
+        { 0x0718, KEY_4 },
+        { 0x071b, KEY_5 },
+        { 0x071e, KEY_6 },
+        { 0x0711, KEY_7 },
+        { 0x0721, KEY_8 },
+        { 0x0712, KEY_9 },
+        { 0x0727, KEY_0 },
+        { 0x0724, KEY_ZOOM }, /* 'Square' key */
+        { 0x072a, KEY_SUBTITLE },   /* 'T' key */
+        { 0x072d, KEY_REWIND },
+        { 0x0730, KEY_PLAYPAUSE },
+        { 0x0733, KEY_FASTFORWARD },
+        { 0x0736, KEY_RECORD },
+        { 0x073c, KEY_STOP },
+        { 0x073f, KEY_HELP }, /* '?' key */
 };
 
 static struct rc_map_list pinnacle_pctv_hd_map = {
         .map = {
                 .scan    = pinnacle_pctv_hd,
                 .size    = ARRAY_SIZE(pinnacle_pctv_hd),
-                .rc_type = RC_TYPE_UNKNOWN,     /* Legacy IR type */
+                .rc_type = RC_TYPE_RC5,
                 .name    = RC_MAP_PINNACLE_PCTV_HD,
         }
 };
diff --git a/drivers/media/rc/lirc_dev.c b/drivers/media/rc/lirc_dev.c
index fd237ab120bb..27997a9ceb0d 100644
--- a/drivers/media/rc/lirc_dev.c
+++ b/drivers/media/rc/lirc_dev.c
@@ -55,6 +55,8 @@ struct irctl {
         struct lirc_buffer *buf;
         unsigned int chunk_size;
 
+        struct cdev *cdev;
+
         struct task_struct *task;
         long jiffies_to_wait;
 };
@@ -62,7 +64,6 @@ struct irctl {
 static DEFINE_MUTEX(lirc_dev_lock);
 
 static struct irctl *irctls[MAX_IRCTL_DEVICES];
-static struct cdev cdevs[MAX_IRCTL_DEVICES];
 
 /* Only used for sysfs but defined to void otherwise */
 static struct class *lirc_class;
@@ -167,9 +168,13 @@ static struct file_operations lirc_dev_fops = {
 
 static int lirc_cdev_add(struct irctl *ir)
 {
-        int retval;
+        int retval = -ENOMEM;
         struct lirc_driver *d = &ir->d;
-        struct cdev *cdev = &cdevs[d->minor];
+        struct cdev *cdev;
+
+        cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
+        if (!cdev)
+                goto err_out;
 
         if (d->fops) {
                 cdev_init(cdev, d->fops);
@@ -180,12 +185,20 @@ static int lirc_cdev_add(struct irctl *ir)
         }
         retval = kobject_set_name(&cdev->kobj, "lirc%d", d->minor);
         if (retval)
-                return retval;
+                goto err_out;
 
         retval = cdev_add(cdev, MKDEV(MAJOR(lirc_base_dev), d->minor), 1);
-        if (retval)
+        if (retval) {
                 kobject_put(&cdev->kobj);
+                goto err_out;
+        }
+
+        ir->cdev = cdev;
+
+        return 0;
 
+err_out:
+        kfree(cdev);
         return retval;
 }
 
@@ -214,7 +227,7 @@ int lirc_register_driver(struct lirc_driver *d)
         if (MAX_IRCTL_DEVICES <= d->minor) {
                 dev_err(d->dev, "lirc_dev: lirc_register_driver: "
                         "\"minor\" must be between 0 and %d (%d)!\n",
-                        MAX_IRCTL_DEVICES-1, d->minor);
+                        MAX_IRCTL_DEVICES - 1, d->minor);
                 err = -EBADRQC;
                 goto out;
         }
@@ -369,7 +382,7 @@ int lirc_unregister_driver(int minor)
 
         if (minor < 0 || minor >= MAX_IRCTL_DEVICES) {
                 printk(KERN_ERR "lirc_dev: %s: minor (%d) must be between "
-                       "0 and %d!\n", __func__, minor, MAX_IRCTL_DEVICES-1);
+                       "0 and %d!\n", __func__, minor, MAX_IRCTL_DEVICES - 1);
                 return -EBADRQC;
         }
 
@@ -380,7 +393,7 @@ int lirc_unregister_driver(int minor)
                 return -ENOENT;
         }
 
-        cdev = &cdevs[minor];
+        cdev = ir->cdev;
 
         mutex_lock(&lirc_dev_lock);
 
@@ -410,6 +423,7 @@ int lirc_unregister_driver(int minor)
         } else {
                 lirc_irctl_cleanup(ir);
                 cdev_del(cdev);
+                kfree(cdev);
                 kfree(ir);
                 irctls[minor] = NULL;
         }
@@ -453,7 +467,7 @@ int lirc_dev_fop_open(struct inode *inode, struct file *file)
                 goto error;
         }
 
-        cdev = &cdevs[iminor(inode)];
+        cdev = ir->cdev;
         if (try_module_get(cdev->owner)) {
                 ir->open++;
                 retval = ir->d.set_use_inc(ir->d.data);
@@ -484,13 +498,15 @@ EXPORT_SYMBOL(lirc_dev_fop_open);
 int lirc_dev_fop_close(struct inode *inode, struct file *file)
 {
         struct irctl *ir = irctls[iminor(inode)];
-        struct cdev *cdev = &cdevs[iminor(inode)];
+        struct cdev *cdev;
 
         if (!ir) {
                 printk(KERN_ERR "%s: called with invalid irctl\n", __func__);
                 return -EINVAL;
         }
 
+        cdev = ir->cdev;
+
         dev_dbg(ir->d.dev, LOGHEAD "close called\n", ir->d.name, ir->d.minor);
 
         WARN_ON(mutex_lock_killable(&lirc_dev_lock));
@@ -503,6 +519,7 @@ int lirc_dev_fop_close(struct inode *inode, struct file *file)
                 lirc_irctl_cleanup(ir);
                 cdev_del(cdev);
                 irctls[ir->d.minor] = NULL;
+                kfree(cdev);
                 kfree(ir);
         }
 
diff --git a/drivers/media/rc/mceusb.c b/drivers/media/rc/mceusb.c
index ad927fcaa020..06dfe0957b5e 100644
--- a/drivers/media/rc/mceusb.c
+++ b/drivers/media/rc/mceusb.c
@@ -108,6 +108,12 @@ static int debug = 1;
 static int debug;
 #endif
 
+#define mce_dbg(dev, fmt, ...)                                  \
+        do {                                                    \
+                if (debug)                                      \
+                        dev_info(dev, fmt, ## __VA_ARGS__);     \
+        } while (0)
+
 /* general constants */
 #define SEND_FLAG_IN_PROGRESS   1
 #define SEND_FLAG_COMPLETE      2
@@ -246,6 +252,9 @@ static struct usb_device_id mceusb_dev_table[] = {
           .driver_info = MCE_GEN2_TX_INV },
         /* SMK eHome Infrared Transceiver */
         { USB_DEVICE(VENDOR_SMK, 0x0338) },
+        /* SMK/I-O Data GV-MC7/RCKIT Receiver */
+        { USB_DEVICE(VENDOR_SMK, 0x0353),
+          .driver_info = MCE_GEN2_NO_TX },
         /* Tatung eHome Infrared Transceiver */
         { USB_DEVICE(VENDOR_TATUNG, 0x9150) },
         /* Shuttle eHome Infrared Transceiver */
@@ -606,12 +615,15 @@ static void mce_async_callback(struct urb *urb, struct pt_regs *regs)
         if (ir) {
                 len = urb->actual_length;
 
-                dev_dbg(ir->dev, "callback called (status=%d len=%d)\n",
+                mce_dbg(ir->dev, "callback called (status=%d len=%d)\n",
                         urb->status, len);
 
                 mceusb_dev_printdata(ir, urb->transfer_buffer, 0, len, true);
         }
 
+        /* the transfer buffer and urb were allocated in mce_request_packet */
+        kfree(urb->transfer_buffer);
+        usb_free_urb(urb);
 }
 
 /* request incoming or send outgoing usb packet - used to initialize remote */
@@ -655,17 +667,17 @@ static void mce_request_packet(struct mceusb_dev *ir, unsigned char *data,
                 return;
         }
 
-        dev_dbg(dev, "receive request called (size=%#x)\n", size);
+        mce_dbg(dev, "receive request called (size=%#x)\n", size);
 
         async_urb->transfer_buffer_length = size;
         async_urb->dev = ir->usbdev;
 
         res = usb_submit_urb(async_urb, GFP_ATOMIC);
         if (res) {
-                dev_dbg(dev, "receive request FAILED! (res=%d)\n", res);
+                mce_dbg(dev, "receive request FAILED! (res=%d)\n", res);
                 return;
         }
-        dev_dbg(dev, "receive request complete (res=%d)\n", res);
+        mce_dbg(dev, "receive request complete (res=%d)\n", res);
 }
 
 static void mce_async_out(struct mceusb_dev *ir, unsigned char *data, int size)
@@ -673,9 +685,9 @@ static void mce_async_out(struct mceusb_dev *ir, unsigned char *data, int size)
         mce_request_packet(ir, data, size, MCEUSB_TX);
 }
 
-static void mce_sync_in(struct mceusb_dev *ir, unsigned char *data, int size)
+static void mce_flush_rx_buffer(struct mceusb_dev *ir, int size)
 {
-        mce_request_packet(ir, data, size, MCEUSB_RX);
+        mce_request_packet(ir, NULL, size, MCEUSB_RX);
 }
 
 /* Send data out the IR blaster port(s) */
@@ -794,7 +806,7 @@ static int mceusb_set_tx_carrier(struct rc_dev *dev, u32 carrier)
                         ir->carrier = carrier;
                         cmdbuf[2] = MCE_CMD_SIG_END;
                         cmdbuf[3] = MCE_IRDATA_TRAILER;
-                        dev_dbg(ir->dev, "%s: disabling carrier "
+                        mce_dbg(ir->dev, "%s: disabling carrier "
                                 "modulation\n", __func__);
                         mce_async_out(ir, cmdbuf, sizeof(cmdbuf));
                         return carrier;
@@ -806,7 +818,7 @@ static int mceusb_set_tx_carrier(struct rc_dev *dev, u32 carrier)
                                 ir->carrier = carrier;
                                 cmdbuf[2] = prescaler;
                                 cmdbuf[3] = divisor;
-                                dev_dbg(ir->dev, "%s: requesting %u HZ "
+                                mce_dbg(ir->dev, "%s: requesting %u HZ "
                                         "carrier\n", __func__, carrier);
 
                                 /* Transmit new carrier to mce device */
@@ -879,7 +891,7 @@ static void mceusb_process_ir_data(struct mceusb_dev *ir, int buf_len)
                         rawir.duration = (ir->buf_in[i] & MCE_PULSE_MASK)
                                          * US_TO_NS(MCE_TIME_UNIT);
 
-                        dev_dbg(ir->dev, "Storing %s with duration %d\n",
+                        mce_dbg(ir->dev, "Storing %s with duration %d\n",
                                 rawir.pulse ? "pulse" : "space",
                                 rawir.duration);
 
@@ -911,7 +923,7 @@ static void mceusb_process_ir_data(struct mceusb_dev *ir, int buf_len)
                 if (ir->parser_state != CMD_HEADER && !ir->rem)
                         ir->parser_state = CMD_HEADER;
         }
-        dev_dbg(ir->dev, "processed IR data, calling ir_raw_event_handle\n");
+        mce_dbg(ir->dev, "processed IR data, calling ir_raw_event_handle\n");
         ir_raw_event_handle(ir->rc);
 }
 
@@ -933,7 +945,7 @@ static void mceusb_dev_recv(struct urb *urb, struct pt_regs *regs)
 
         if (ir->send_flags == RECV_FLAG_IN_PROGRESS) {
                 ir->send_flags = SEND_FLAG_COMPLETE;
-                dev_dbg(ir->dev, "setup answer received %d bytes\n",
+                mce_dbg(ir->dev, "setup answer received %d bytes\n",
                         buf_len);
         }
 
@@ -951,7 +963,7 @@ static void mceusb_dev_recv(struct urb *urb, struct pt_regs *regs)
 
         case -EPIPE:
         default:
-                dev_dbg(ir->dev, "Error: urb status = %d\n", urb->status);
+                mce_dbg(ir->dev, "Error: urb status = %d\n", urb->status);
                 break;
         }
 
@@ -961,7 +973,6 @@ static void mceusb_dev_recv(struct urb *urb, struct pt_regs *regs)
 static void mceusb_gen1_init(struct mceusb_dev *ir)
 {
         int ret;
-        int maxp = ir->len_in;
         struct device *dev = ir->dev;
         char *data;
 
@@ -978,8 +989,8 @@ static void mceusb_gen1_init(struct mceusb_dev *ir)
         ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
                               USB_REQ_SET_ADDRESS, USB_TYPE_VENDOR, 0, 0,
                               data, USB_CTRL_MSG_SZ, HZ * 3);
-        dev_dbg(dev, "%s - ret = %d\n", __func__, ret);
-        dev_dbg(dev, "%s - data[0] = %d, data[1] = %d\n",
+        mce_dbg(dev, "%s - ret = %d\n", __func__, ret);
+        mce_dbg(dev, "%s - data[0] = %d, data[1] = %d\n",
                 __func__, data[0], data[1]);
 
         /* set feature: bit rate 38400 bps */
@@ -987,71 +998,56 @@ static void mceusb_gen1_init(struct mceusb_dev *ir)
                               USB_REQ_SET_FEATURE, USB_TYPE_VENDOR,
                               0xc04e, 0x0000, NULL, 0, HZ * 3);
 
-        dev_dbg(dev, "%s - ret = %d\n", __func__, ret);
+        mce_dbg(dev, "%s - ret = %d\n", __func__, ret);
 
         /* bRequest 4: set char length to 8 bits */
         ret = usb_control_msg(ir->usbdev, usb_sndctrlpipe(ir->usbdev, 0),
                               4, USB_TYPE_VENDOR,
                               0x0808, 0x0000, NULL, 0, HZ * 3);
-        dev_dbg(dev, "%s - retB = %d\n", __func__, ret);
+        mce_dbg(dev, "%s - retB = %d\n", __func__, ret);
 
         /* bRequest 2: set handshaking to use DTR/DSR */
         ret = usb_control_msg(ir->usbdev, usb_sndctrlpipe(ir->usbdev, 0),
                               2, USB_TYPE_VENDOR,
                               0x0000, 0x0100, NULL, 0, HZ * 3);
-        dev_dbg(dev, "%s - retC = %d\n", __func__, ret);
+        mce_dbg(dev, "%s - retC = %d\n", __func__, 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);
 };
 
 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);
 
-        if (!ir->flags.no_tx) {
+        if (!ir->flags.no_tx)
                 /* 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 struct rc_dev *mceusb_init_rc_dev(struct mceusb_dev *ir)
@@ -1122,7 +1118,7 @@ static int __devinit mceusb_dev_probe(struct usb_interface *intf,
         bool tx_mask_normal;
         int ir_intfnum;
 
-        dev_dbg(&intf->dev, "%s called\n", __func__);
+        mce_dbg(&intf->dev, "%s called\n", __func__);
 
         idesc  = intf->cur_altsetting;
 
@@ -1150,7 +1146,7 @@ static int __devinit mceusb_dev_probe(struct usb_interface *intf,
                         ep_in = ep;
                         ep_in->bmAttributes = USB_ENDPOINT_XFER_INT;
                         ep_in->bInterval = 1;
-                        dev_dbg(&intf->dev, "acceptable inbound endpoint "
+                        mce_dbg(&intf->dev, "acceptable inbound endpoint "
                                 "found\n");
                 }
 
@@ -1165,12 +1161,12 @@ static int __devinit mceusb_dev_probe(struct usb_interface *intf,
                         ep_out = ep;
                         ep_out->bmAttributes = USB_ENDPOINT_XFER_INT;
                         ep_out->bInterval = 1;
-                        dev_dbg(&intf->dev, "acceptable outbound endpoint "
+                        mce_dbg(&intf->dev, "acceptable outbound endpoint "
                                 "found\n");
                 }
         }
         if (ep_in == NULL) {
-                dev_dbg(&intf->dev, "inbound and/or endpoint not found\n");
+                mce_dbg(&intf->dev, "inbound and/or endpoint not found\n");
                 return -ENODEV;
         }
 
@@ -1215,16 +1211,16 @@ static int __devinit mceusb_dev_probe(struct usb_interface *intf,
         if (!ir->rc)
                 goto rc_dev_fail;
 
-        /* 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;
 
+        /* flush buffers on the device */
+        mce_dbg(&intf->dev, "Flushing receive buffers\n");
+        mce_flush_rx_buffer(ir, maxp);
+
         /* initialize device */
         if (ir->flags.microsoft_gen1)
                 mceusb_gen1_init(ir);
diff --git a/drivers/media/rc/nuvoton-cir.c b/drivers/media/rc/nuvoton-cir.c
index bf3060ea6107..565f24c20d77 100644
--- a/drivers/media/rc/nuvoton-cir.c
+++ b/drivers/media/rc/nuvoton-cir.c
@@ -991,7 +991,6 @@ static int nvt_open(struct rc_dev *dev)
         unsigned long flags;
 
         spin_lock_irqsave(&nvt->nvt_lock, flags);
-        nvt->in_use = true;
         nvt_enable_cir(nvt);
         spin_unlock_irqrestore(&nvt->nvt_lock, flags);
 
@@ -1004,7 +1003,6 @@ static void nvt_close(struct rc_dev *dev)
         unsigned long flags;
 
         spin_lock_irqsave(&nvt->nvt_lock, flags);
-        nvt->in_use = false;
         nvt_disable_cir(nvt);
         spin_unlock_irqrestore(&nvt->nvt_lock, flags);
 }
diff --git a/drivers/media/rc/nuvoton-cir.h b/drivers/media/rc/nuvoton-cir.h
index 379795d61ea7..1241fc89a36c 100644
--- a/drivers/media/rc/nuvoton-cir.h
+++ b/drivers/media/rc/nuvoton-cir.h
@@ -70,7 +70,6 @@ struct nvt_dev {
         struct ir_raw_event rawir;
 
         spinlock_t nvt_lock;
-        bool in_use;
 
         /* for rx */
         u8 buf[RX_BUF_LEN];
diff --git a/drivers/media/rc/rc-main.c b/drivers/media/rc/rc-main.c
index f57cd5677ac2..3186ac7c2c10 100644
--- a/drivers/media/rc/rc-main.c
+++ b/drivers/media/rc/rc-main.c
@@ -522,18 +522,20 @@ EXPORT_SYMBOL_GPL(rc_g_keycode_from_table);
 /**
  * ir_do_keyup() - internal function to signal the release of a keypress
  * @dev:        the struct rc_dev descriptor of the device
+ * @sync:       whether or not to call input_sync
  *
  * This function is used internally to release a keypress, it must be
  * called with keylock held.
  */
-static void ir_do_keyup(struct rc_dev *dev)
+static void ir_do_keyup(struct rc_dev *dev, bool sync)
 {
         if (!dev->keypressed)
                 return;
 
         IR_dprintk(1, "keyup key 0x%04x\n", dev->last_keycode);
         input_report_key(dev->input_dev, dev->last_keycode, 0);
-        input_sync(dev->input_dev);
+        if (sync)
+                input_sync(dev->input_dev);
         dev->keypressed = false;
 }
 
@@ -549,7 +551,7 @@ void rc_keyup(struct rc_dev *dev)
         unsigned long flags;
 
         spin_lock_irqsave(&dev->keylock, flags);
-        ir_do_keyup(dev);
+        ir_do_keyup(dev, true);
         spin_unlock_irqrestore(&dev->keylock, flags);
 }
 EXPORT_SYMBOL_GPL(rc_keyup);
@@ -578,7 +580,7 @@ static void ir_timer_keyup(unsigned long cookie)
          */
         spin_lock_irqsave(&dev->keylock, flags);
         if (time_is_before_eq_jiffies(dev->keyup_jiffies))
-                ir_do_keyup(dev);
+                ir_do_keyup(dev, true);
         spin_unlock_irqrestore(&dev->keylock, flags);
 }
 
@@ -597,6 +599,7 @@ void rc_repeat(struct rc_dev *dev)
         spin_lock_irqsave(&dev->keylock, flags);
 
         input_event(dev->input_dev, EV_MSC, MSC_SCAN, dev->last_scancode);
+        input_sync(dev->input_dev);
 
         if (!dev->keypressed)
                 goto out;
@@ -622,29 +625,28 @@ EXPORT_SYMBOL_GPL(rc_repeat);
 static void ir_do_keydown(struct rc_dev *dev, int scancode,
                           u32 keycode, u8 toggle)
 {
-        input_event(dev->input_dev, EV_MSC, MSC_SCAN, scancode);
-
-        /* Repeat event? */
-        if (dev->keypressed &&
-            dev->last_scancode == scancode &&
-            dev->last_toggle == toggle)
-                return;
+        bool new_event = !dev->keypressed ||
+                         dev->last_scancode != scancode ||
+                         dev->last_toggle != toggle;
 
-        /* Release old keypress */
-        ir_do_keyup(dev);
+        if (new_event && dev->keypressed)
+                ir_do_keyup(dev, false);
 
-        dev->last_scancode = scancode;
-        dev->last_toggle = toggle;
-        dev->last_keycode = keycode;
+        input_event(dev->input_dev, EV_MSC, MSC_SCAN, scancode);
 
-        if (keycode == KEY_RESERVED)
-                return;
+        if (new_event && keycode != KEY_RESERVED) {
+                /* Register a keypress */
+                dev->keypressed = true;
+                dev->last_scancode = scancode;
+                dev->last_toggle = toggle;
+                dev->last_keycode = keycode;
+
+                IR_dprintk(1, "%s: key down event, "
+                           "key 0x%04x, scancode 0x%04x\n",
+                           dev->input_name, keycode, scancode);
+                input_report_key(dev->input_dev, keycode, 1);
+        }
 
-        /* Register a keypress */
-        dev->keypressed = true;
-        IR_dprintk(1, "%s: key down event, key 0x%04x, scancode 0x%04x\n",
-                   dev->input_name, keycode, scancode);
-        input_report_key(dev->input_dev, dev->last_keycode, 1);
         input_sync(dev->input_dev);
 }