Merge branch 'next' into for-linus

Merge first round of changes for 3.13 merge window.

6 files changed, 465 insertions, 14 deletions

diff --git a/drivers/input/serio/Kconfig b/drivers/input/serio/Kconfig
index 1e691a3a79cb..5a96acb667ea 100644
--- a/drivers/input/serio/Kconfig
+++ b/drivers/input/serio/Kconfig
@@ -2,7 +2,7 @@
 # Input core configuration
 #
 config SERIO
-        tristate "Serial I/O support" if EXPERT || !X86
+        tristate "Serial I/O support"
         default y
         help
           Say Yes here if you have any input device that uses serial I/O to
@@ -19,7 +19,7 @@ config SERIO
 if SERIO
 
 config SERIO_I8042
-        tristate "i8042 PC Keyboard controller" if EXPERT || !X86
+        tristate "i8042 PC Keyboard controller"
         default y
         depends on !PARISC && (!ARM || ARCH_SHARK || FOOTBRIDGE_HOST) && \
                    (!SUPERH || SH_CAYMAN) && !M68K && !BLACKFIN && !S390 && \
@@ -170,7 +170,7 @@ config SERIO_MACEPS2
           module will be called maceps2.
 
 config SERIO_LIBPS2
-        tristate "PS/2 driver library" if EXPERT
+        tristate "PS/2 driver library"
         depends on SERIO_I8042 || SERIO_I8042=n
         help
           Say Y here if you are using a driver for device connected
@@ -239,7 +239,6 @@ config SERIO_PS2MULT
 
 config SERIO_ARC_PS2
         tristate "ARC PS/2 support"
-        depends on GENERIC_HARDIRQS
         help
           Say Y here if you have an ARC FPGA platform with a PS/2
           controller in it.
@@ -267,4 +266,14 @@ config SERIO_OLPC_APSP
           To compile this driver as a module, choose M here: the module will
           be called olpc_apsp.
 
+config HYPERV_KEYBOARD
+        tristate "Microsoft Synthetic Keyboard driver"
+        depends on HYPERV
+        default HYPERV
+        help
+          Select this option to enable the Hyper-V Keyboard driver.
+
+          To compile this driver as a module, choose M here: the module will
+          be called hyperv_keyboard.
+
 endif
diff --git a/drivers/input/serio/Makefile b/drivers/input/serio/Makefile
index 12298b1c0e71..815d874fe724 100644
--- a/drivers/input/serio/Makefile
+++ b/drivers/input/serio/Makefile
@@ -28,3 +28,4 @@ obj-$(CONFIG_SERIO_ALTERA_PS2)	+= altera_ps2.o
 obj-$(CONFIG_SERIO_ARC_PS2)     += arc_ps2.o
 obj-$(CONFIG_SERIO_APBPS2)      += apbps2.o
 obj-$(CONFIG_SERIO_OLPC_APSP)   += olpc_apsp.o
+obj-$(CONFIG_HYPERV_KEYBOARD)   += hyperv-keyboard.o
diff --git a/drivers/input/serio/altera_ps2.c b/drivers/input/serio/altera_ps2.c
index a0a2657e31ff..4777a73cd390 100644
--- a/drivers/input/serio/altera_ps2.c
+++ b/drivers/input/serio/altera_ps2.c
@@ -176,6 +176,7 @@ static int altera_ps2_remove(struct platform_device *pdev)
 #ifdef CONFIG_OF
 static const struct of_device_id altera_ps2_match[] = {
         { .compatible = "ALTR,ps2-1.0", },
+        { .compatible = "altr,ps2-1.0", },
         {},
 };
 MODULE_DEVICE_TABLE(of, altera_ps2_match);
diff --git a/drivers/input/serio/hyperv-keyboard.c b/drivers/input/serio/hyperv-keyboard.c
new file mode 100644
index 000000000000..3a83c3c14b23
--- /dev/null
+++ b/drivers/input/serio/hyperv-keyboard.c
@@ -0,0 +1,437 @@
+/*
+ *  Copyright (c) 2013, Microsoft Corporation.
+ *
+ *  This program is free software; you can redistribute it and/or modify it
+ *  under the terms and conditions of the GNU General Public License,
+ *  version 2, as published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ *  more details.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/completion.h>
+#include <linux/hyperv.h>
+#include <linux/serio.h>
+#include <linux/slab.h>
+
+/*
+ * Current version 1.0
+ *
+ */
+#define SYNTH_KBD_VERSION_MAJOR 1
+#define SYNTH_KBD_VERSION_MINOR 0
+#define SYNTH_KBD_VERSION               (SYNTH_KBD_VERSION_MINOR | \
+                                         (SYNTH_KBD_VERSION_MAJOR << 16))
+
+
+/*
+ * Message types in the synthetic input protocol
+ */
+enum synth_kbd_msg_type {
+        SYNTH_KBD_PROTOCOL_REQUEST = 1,
+        SYNTH_KBD_PROTOCOL_RESPONSE = 2,
+        SYNTH_KBD_EVENT = 3,
+        SYNTH_KBD_LED_INDICATORS = 4,
+};
+
+/*
+ * Basic message structures.
+ */
+struct synth_kbd_msg_hdr {
+        __le32 type;
+};
+
+struct synth_kbd_msg {
+        struct synth_kbd_msg_hdr header;
+        char data[]; /* Enclosed message */
+};
+
+union synth_kbd_version {
+        __le32 version;
+};
+
+/*
+ * Protocol messages
+ */
+struct synth_kbd_protocol_request {
+        struct synth_kbd_msg_hdr header;
+        union synth_kbd_version version_requested;
+};
+
+#define PROTOCOL_ACCEPTED       BIT(0)
+struct synth_kbd_protocol_response {
+        struct synth_kbd_msg_hdr header;
+        __le32 proto_status;
+};
+
+#define IS_UNICODE      BIT(0)
+#define IS_BREAK        BIT(1)
+#define IS_E0           BIT(2)
+#define IS_E1           BIT(3)
+struct synth_kbd_keystroke {
+        struct synth_kbd_msg_hdr header;
+        __le16 make_code;
+        __le16 reserved0;
+        __le32 info; /* Additional information */
+};
+
+
+#define HK_MAXIMUM_MESSAGE_SIZE 256
+
+#define KBD_VSC_SEND_RING_BUFFER_SIZE           (10 * PAGE_SIZE)
+#define KBD_VSC_RECV_RING_BUFFER_SIZE           (10 * PAGE_SIZE)
+
+#define XTKBD_EMUL0     0xe0
+#define XTKBD_EMUL1     0xe1
+#define XTKBD_RELEASE   0x80
+
+
+/*
+ * Represents a keyboard device
+ */
+struct hv_kbd_dev {
+        struct hv_device *hv_dev;
+        struct serio *hv_serio;
+        struct synth_kbd_protocol_request protocol_req;
+        struct synth_kbd_protocol_response protocol_resp;
+        /* Synchronize the request/response if needed */
+        struct completion wait_event;
+        spinlock_t lock; /* protects 'started' field */
+        bool started;
+};
+
+static void hv_kbd_on_receive(struct hv_device *hv_dev,
+                              struct synth_kbd_msg *msg, u32 msg_length)
+{
+        struct hv_kbd_dev *kbd_dev = hv_get_drvdata(hv_dev);
+        struct synth_kbd_keystroke *ks_msg;
+        unsigned long flags;
+        u32 msg_type = __le32_to_cpu(msg->header.type);
+        u32 info;
+        u16 scan_code;
+
+        switch (msg_type) {
+        case SYNTH_KBD_PROTOCOL_RESPONSE:
+                /*
+                 * Validate the information provided by the host.
+                 * If the host is giving us a bogus packet,
+                 * drop the packet (hoping the problem
+                 * goes away).
+                 */
+                if (msg_length < sizeof(struct synth_kbd_protocol_response)) {
+                        dev_err(&hv_dev->device,
+                                "Illegal protocol response packet (len: %d)\n",
+                                msg_length);
+                        break;
+                }
+
+                memcpy(&kbd_dev->protocol_resp, msg,
+                        sizeof(struct synth_kbd_protocol_response));
+                complete(&kbd_dev->wait_event);
+                break;
+
+        case SYNTH_KBD_EVENT:
+                /*
+                 * Validate the information provided by the host.
+                 * If the host is giving us a bogus packet,
+                 * drop the packet (hoping the problem
+                 * goes away).
+                 */
+                if (msg_length < sizeof(struct  synth_kbd_keystroke)) {
+                        dev_err(&hv_dev->device,
+                                "Illegal keyboard event packet (len: %d)\n",
+                                msg_length);
+                        break;
+                }
+
+                ks_msg = (struct synth_kbd_keystroke *)msg;
+                info = __le32_to_cpu(ks_msg->info);
+
+                /*
+                 * Inject the information through the serio interrupt.
+                 */
+                spin_lock_irqsave(&kbd_dev->lock, flags);
+                if (kbd_dev->started) {
+                        if (info & IS_E0)
+                                serio_interrupt(kbd_dev->hv_serio,
+                                                XTKBD_EMUL0, 0);
+
+                        scan_code = __le16_to_cpu(ks_msg->make_code);
+                        if (info & IS_BREAK)
+                                scan_code |= XTKBD_RELEASE;
+
+                        serio_interrupt(kbd_dev->hv_serio, scan_code, 0);
+                }
+                spin_unlock_irqrestore(&kbd_dev->lock, flags);
+                break;
+
+        default:
+                dev_err(&hv_dev->device,
+                        "unhandled message type %d\n", msg_type);
+        }
+}
+
+static void hv_kbd_handle_received_packet(struct hv_device *hv_dev,
+                                          struct vmpacket_descriptor *desc,
+                                          u32 bytes_recvd,
+                                          u64 req_id)
+{
+        struct synth_kbd_msg *msg;
+        u32 msg_sz;
+
+        switch (desc->type) {
+        case VM_PKT_COMP:
+                break;
+
+        case VM_PKT_DATA_INBAND:
+                /*
+                 * We have a packet that has "inband" data. The API used
+                 * for retrieving the packet guarantees that the complete
+                 * packet is read. So, minimally, we should be able to
+                 * parse the payload header safely (assuming that the host
+                 * can be trusted.  Trusting the host seems to be a
+                 * reasonable assumption because in a virtualized
+                 * environment there is not whole lot you can do if you
+                 * don't trust the host.
+                 *
+                 * Nonetheless, let us validate if the host can be trusted
+                 * (in a trivial way).  The interesting aspect of this
+                 * validation is how do you recover if we discover that the
+                 * host is not to be trusted? Simply dropping the packet, I
+                 * don't think is an appropriate recovery.  In the interest
+                 * of failing fast, it may be better to crash the guest.
+                 * For now, I will just drop the packet!
+                 */
+
+                msg_sz = bytes_recvd - (desc->offset8 << 3);
+                if (msg_sz <= sizeof(struct synth_kbd_msg_hdr)) {
+                        /*
+                         * Drop the packet and hope
+                         * the problem magically goes away.
+                         */
+                        dev_err(&hv_dev->device,
+                                "Illegal packet (type: %d, tid: %llx, size: %d)\n",
+                                desc->type, req_id, msg_sz);
+                        break;
+                }
+
+                msg = (void *)desc + (desc->offset8 << 3);
+                hv_kbd_on_receive(hv_dev, msg, msg_sz);
+                break;
+
+        default:
+                dev_err(&hv_dev->device,
+                        "unhandled packet type %d, tid %llx len %d\n",
+                        desc->type, req_id, bytes_recvd);
+                break;
+        }
+}
+
+static void hv_kbd_on_channel_callback(void *context)
+{
+        struct hv_device *hv_dev = context;
+        void *buffer;
+        int bufferlen = 0x100; /* Start with sensible size */
+        u32 bytes_recvd;
+        u64 req_id;
+        int error;
+
+        buffer = kmalloc(bufferlen, GFP_ATOMIC);
+        if (!buffer)
+                return;
+
+        while (1) {
+                error = vmbus_recvpacket_raw(hv_dev->channel, buffer, bufferlen,
+                                             &bytes_recvd, &req_id);
+                switch (error) {
+                case 0:
+                        if (bytes_recvd == 0) {
+                                kfree(buffer);
+                                return;
+                        }
+
+                        hv_kbd_handle_received_packet(hv_dev, buffer,
+                                                      bytes_recvd, req_id);
+                        break;
+
+                case -ENOBUFS:
+                        kfree(buffer);
+                        /* Handle large packet */
+                        bufferlen = bytes_recvd;
+                        buffer = kmalloc(bytes_recvd, GFP_ATOMIC);
+                        if (!buffer)
+                                return;
+                        break;
+                }
+        }
+}
+
+static int hv_kbd_connect_to_vsp(struct hv_device *hv_dev)
+{
+        struct hv_kbd_dev *kbd_dev = hv_get_drvdata(hv_dev);
+        struct synth_kbd_protocol_request *request;
+        struct synth_kbd_protocol_response *response;
+        u32 proto_status;
+        int error;
+
+        request = &kbd_dev->protocol_req;
+        memset(request, 0, sizeof(struct synth_kbd_protocol_request));
+        request->header.type = __cpu_to_le32(SYNTH_KBD_PROTOCOL_REQUEST);
+        request->version_requested.version = __cpu_to_le32(SYNTH_KBD_VERSION);
+
+        error = vmbus_sendpacket(hv_dev->channel, request,
+                                 sizeof(struct synth_kbd_protocol_request),
+                                 (unsigned long)request,
+                                 VM_PKT_DATA_INBAND,
+                                 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
+        if (error)
+                return error;
+
+        if (!wait_for_completion_timeout(&kbd_dev->wait_event, 10 * HZ))
+                return -ETIMEDOUT;
+
+        response = &kbd_dev->protocol_resp;
+        proto_status = __le32_to_cpu(response->proto_status);
+        if (!(proto_status & PROTOCOL_ACCEPTED)) {
+                dev_err(&hv_dev->device,
+                        "synth_kbd protocol request failed (version %d)\n",
+                        SYNTH_KBD_VERSION);
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static int hv_kbd_start(struct serio *serio)
+{
+        struct hv_kbd_dev *kbd_dev = serio->port_data;
+        unsigned long flags;
+
+        spin_lock_irqsave(&kbd_dev->lock, flags);
+        kbd_dev->started = true;
+        spin_unlock_irqrestore(&kbd_dev->lock, flags);
+
+        return 0;
+}
+
+static void hv_kbd_stop(struct serio *serio)
+{
+        struct hv_kbd_dev *kbd_dev = serio->port_data;
+        unsigned long flags;
+
+        spin_lock_irqsave(&kbd_dev->lock, flags);
+        kbd_dev->started = false;
+        spin_unlock_irqrestore(&kbd_dev->lock, flags);
+}
+
+static int hv_kbd_probe(struct hv_device *hv_dev,
+                        const struct hv_vmbus_device_id *dev_id)
+{
+        struct hv_kbd_dev *kbd_dev;
+        struct serio *hv_serio;
+        int error;
+
+        kbd_dev = kzalloc(sizeof(struct hv_kbd_dev), GFP_KERNEL);
+        hv_serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
+        if (!kbd_dev || !hv_serio) {
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        kbd_dev->hv_dev = hv_dev;
+        kbd_dev->hv_serio = hv_serio;
+        spin_lock_init(&kbd_dev->lock);
+        init_completion(&kbd_dev->wait_event);
+        hv_set_drvdata(hv_dev, kbd_dev);
+
+        hv_serio->dev.parent  = &hv_dev->device;
+        hv_serio->id.type = SERIO_8042_XL;
+        hv_serio->port_data = kbd_dev;
+        strlcpy(hv_serio->name, dev_name(&hv_dev->device),
+                sizeof(hv_serio->name));
+        strlcpy(hv_serio->phys, dev_name(&hv_dev->device),
+                sizeof(hv_serio->phys));
+
+        hv_serio->start = hv_kbd_start;
+        hv_serio->stop = hv_kbd_stop;
+
+        error = vmbus_open(hv_dev->channel,
+                           KBD_VSC_SEND_RING_BUFFER_SIZE,
+                           KBD_VSC_RECV_RING_BUFFER_SIZE,
+                           NULL, 0,
+                           hv_kbd_on_channel_callback,
+                           hv_dev);
+        if (error)
+                goto err_free_mem;
+
+        error = hv_kbd_connect_to_vsp(hv_dev);
+        if (error)
+                goto err_close_vmbus;
+
+        serio_register_port(kbd_dev->hv_serio);
+        return 0;
+
+err_close_vmbus:
+        vmbus_close(hv_dev->channel);
+err_free_mem:
+        kfree(hv_serio);
+        kfree(kbd_dev);
+        return error;
+}
+
+static int hv_kbd_remove(struct hv_device *hv_dev)
+{
+        struct hv_kbd_dev *kbd_dev = hv_get_drvdata(hv_dev);
+
+        serio_unregister_port(kbd_dev->hv_serio);
+        vmbus_close(hv_dev->channel);
+        kfree(kbd_dev);
+
+        hv_set_drvdata(hv_dev, NULL);
+
+        return 0;
+}
+
+/*
+ * Keyboard GUID
+ * {f912ad6d-2b17-48ea-bd65-f927a61c7684}
+ */
+#define HV_KBD_GUID \
+        .guid = { \
+                        0x6d, 0xad, 0x12, 0xf9, 0x17, 0x2b, 0xea, 0x48, \
+                        0xbd, 0x65, 0xf9, 0x27, 0xa6, 0x1c, 0x76, 0x84 \
+        }
+
+static const struct hv_vmbus_device_id id_table[] = {
+        /* Keyboard guid */
+        { HV_KBD_GUID, },
+        { },
+};
+
+MODULE_DEVICE_TABLE(vmbus, id_table);
+
+static struct  hv_driver hv_kbd_drv = {
+        .name = KBUILD_MODNAME,
+        .id_table = id_table,
+        .probe = hv_kbd_probe,
+        .remove = hv_kbd_remove,
+};
+
+static int __init hv_kbd_init(void)
+{
+        return vmbus_driver_register(&hv_kbd_drv);
+}
+
+static void __exit hv_kbd_exit(void)
+{
+        vmbus_driver_unregister(&hv_kbd_drv);
+}
+
+MODULE_LICENSE("GPL");
+module_init(hv_kbd_init);
+module_exit(hv_kbd_exit);
diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h
index 5f306f79da0c..0ec9abbe31fe 100644
--- a/drivers/input/serio/i8042-x86ia64io.h
+++ b/drivers/input/serio/i8042-x86ia64io.h
@@ -765,6 +765,7 @@ static struct pnp_device_id pnp_kbd_devids[] = {
         { .id = "CPQA0D7", .driver_data = 0 },
         { .id = "", },
 };
+MODULE_DEVICE_TABLE(pnp, pnp_kbd_devids);
 
 static struct pnp_driver i8042_pnp_kbd_driver = {
         .name           = "i8042 kbd",
@@ -786,6 +787,7 @@ static struct pnp_device_id pnp_aux_devids[] = {
         { .id = "SYN0801", .driver_data = 0 },
         { .id = "", },
 };
+MODULE_DEVICE_TABLE(pnp, pnp_aux_devids);
 
 static struct pnp_driver i8042_pnp_aux_driver = {
         .name           = "i8042 aux",
diff --git a/drivers/input/serio/serio.c b/drivers/input/serio/serio.c
index 25fc5971f426..2b56855c2c77 100644
--- a/drivers/input/serio/serio.c
+++ b/drivers/input/serio/serio.c
@@ -732,19 +732,20 @@ EXPORT_SYMBOL(serio_unregister_child_port);
  * Serio driver operations
  */
 
-static ssize_t serio_driver_show_description(struct device_driver *drv, char *buf)
+static ssize_t description_show(struct device_driver *drv, char *buf)
 {
         struct serio_driver *driver = to_serio_driver(drv);
         return sprintf(buf, "%s\n", driver->description ? driver->description : "(none)");
 }
+static DRIVER_ATTR_RO(description);
 
-static ssize_t serio_driver_show_bind_mode(struct device_driver *drv, char *buf)
+static ssize_t bind_mode_show(struct device_driver *drv, char *buf)
 {
         struct serio_driver *serio_drv = to_serio_driver(drv);
         return sprintf(buf, "%s\n", serio_drv->manual_bind ? "manual" : "auto");
 }
 
-static ssize_t serio_driver_set_bind_mode(struct device_driver *drv, const char *buf, size_t count)
+static ssize_t bind_mode_store(struct device_driver *drv, const char *buf, size_t count)
 {
         struct serio_driver *serio_drv = to_serio_driver(drv);
         int retval;
@@ -760,14 +761,14 @@ static ssize_t serio_driver_set_bind_mode(struct device_driver *drv, const char
 
         return retval;
 }
+static DRIVER_ATTR_RW(bind_mode);
 
-
-static struct driver_attribute serio_driver_attrs[] = {
-        __ATTR(description, S_IRUGO, serio_driver_show_description, NULL),
-        __ATTR(bind_mode, S_IWUSR | S_IRUGO,
-                serio_driver_show_bind_mode, serio_driver_set_bind_mode),
-        __ATTR_NULL
+static struct attribute *serio_driver_attrs[] = {
+        &driver_attr_description.attr,
+        &driver_attr_bind_mode.attr,
+        NULL,
 };
+ATTRIBUTE_GROUPS(serio_driver);
 
 static int serio_driver_probe(struct device *dev)
 {
@@ -996,7 +997,7 @@ EXPORT_SYMBOL(serio_interrupt);
 static struct bus_type serio_bus = {
         .name           = "serio",
         .dev_attrs      = serio_device_attrs,
-        .drv_attrs      = serio_driver_attrs,
+        .drv_groups     = serio_driver_groups,
         .match          = serio_bus_match,
         .uevent         = serio_uevent,
         .probe          = serio_driver_probe,