Merge branch 'master' of /home/davem/src/GIT/linux-2.6/

Conflicts:
	drivers/firmware/iscsi_ibft.c

5 files changed, 352 insertions, 23 deletions

diff --git a/drivers/media/IR/Makefile b/drivers/media/IR/Makefile
index df5ddb4bbbf7..171890e7a41d 100644
--- a/drivers/media/IR/Makefile
+++ b/drivers/media/IR/Makefile
@@ -1,5 +1,5 @@
 ir-common-objs  := ir-functions.o ir-keymaps.o
-ir-core-objs    := ir-keytable.o
+ir-core-objs    := ir-keytable.o ir-sysfs.o
 
 obj-$(CONFIG_IR_CORE) += ir-core.o
 obj-$(CONFIG_VIDEO_IR) += ir-common.o
diff --git a/drivers/media/IR/ir-functions.c b/drivers/media/IR/ir-functions.c
index 776a136616d6..ab06919ad5fc 100644
--- a/drivers/media/IR/ir-functions.c
+++ b/drivers/media/IR/ir-functions.c
@@ -52,7 +52,7 @@ static void ir_input_key_event(struct input_dev *dev, struct ir_input_state *ir)
 /* -------------------------------------------------------------------------- */
 
 int ir_input_init(struct input_dev *dev, struct ir_input_state *ir,
-                   int ir_type)
+                  const u64 ir_type)
 {
         ir->ir_type = ir_type;
 
diff --git a/drivers/media/IR/ir-keymaps.c b/drivers/media/IR/ir-keymaps.c
index 9bbe6b1e9871..0efdefe75f32 100644
--- a/drivers/media/IR/ir-keymaps.c
+++ b/drivers/media/IR/ir-keymaps.c
@@ -3393,3 +3393,102 @@ struct ir_scancode_table ir_codes_nec_terratec_cinergy_xs_table = {
 };
 EXPORT_SYMBOL_GPL(ir_codes_nec_terratec_cinergy_xs_table);
 
+
+/* Leadtek Winfast TV USB II Deluxe remote
+   Magnus Alm <magnus.alm@gmail.com>
+ */
+static struct ir_scancode ir_codes_winfast_usbii_deluxe[] = {
+        { 0x62, KEY_0},
+        { 0x75, KEY_1},
+        { 0x76, KEY_2},
+        { 0x77, KEY_3},
+        { 0x79, KEY_4},
+        { 0x7a, KEY_5},
+        { 0x7b, KEY_6},
+        { 0x7d, KEY_7},
+        { 0x7e, KEY_8},
+        { 0x7f, KEY_9},
+
+        { 0x38, KEY_CAMERA},            /* SNAPSHOT */
+        { 0x37, KEY_RECORD},            /* RECORD */
+        { 0x35, KEY_TIME},              /* TIMESHIFT */
+
+        { 0x74, KEY_VOLUMEUP},          /* VOLUMEUP */
+        { 0x78, KEY_VOLUMEDOWN},        /* VOLUMEDOWN */
+        { 0x64, KEY_MUTE},              /* MUTE */
+
+        { 0x21, KEY_CHANNEL},           /* SURF */
+        { 0x7c, KEY_CHANNELUP},         /* CHANNELUP */
+        { 0x60, KEY_CHANNELDOWN},       /* CHANNELDOWN */
+        { 0x61, KEY_LAST},              /* LAST CHANNEL (RECALL) */
+
+        { 0x72, KEY_VIDEO},             /* INPUT MODES (TV/FM) */
+
+        { 0x70, KEY_POWER2},            /* TV ON/OFF */
+
+        { 0x39, KEY_CYCLEWINDOWS},      /* MINIMIZE (BOSS) */
+        { 0x3a, KEY_NEW},               /* PIP */
+        { 0x73, KEY_ZOOM},              /* FULLSECREEN */
+
+        { 0x66, KEY_INFO},              /* OSD (DISPLAY) */
+
+        { 0x31, KEY_DOT},               /* '.' */
+        { 0x63, KEY_ENTER},             /* ENTER */
+
+};
+struct ir_scancode_table ir_codes_winfast_usbii_deluxe_table = {
+        .scan = ir_codes_winfast_usbii_deluxe,
+        .size = ARRAY_SIZE(ir_codes_winfast_usbii_deluxe),
+};
+EXPORT_SYMBOL_GPL(ir_codes_winfast_usbii_deluxe_table);
+
+/* Kworld 315U
+ */
+static struct ir_scancode ir_codes_kworld_315u[] = {
+        { 0x6143, KEY_POWER },
+        { 0x6101, KEY_TUNER },          /* source */
+        { 0x610b, KEY_ZOOM },
+        { 0x6103, KEY_POWER2 },         /* shutdown */
+
+        { 0x6104, KEY_1 },
+        { 0x6108, KEY_2 },
+        { 0x6102, KEY_3 },
+        { 0x6109, KEY_CHANNELUP },
+
+        { 0x610f, KEY_4 },
+        { 0x6105, KEY_5 },
+        { 0x6106, KEY_6 },
+        { 0x6107, KEY_CHANNELDOWN },
+
+        { 0x610c, KEY_7 },
+        { 0x610d, KEY_8 },
+        { 0x610a, KEY_9 },
+        { 0x610e, KEY_VOLUMEUP },
+
+        { 0x6110, KEY_LAST },
+        { 0x6111, KEY_0 },
+        { 0x6112, KEY_ENTER },
+        { 0x6113, KEY_VOLUMEDOWN },
+
+        { 0x6114, KEY_RECORD },
+        { 0x6115, KEY_STOP },
+        { 0x6116, KEY_PLAY },
+        { 0x6117, KEY_MUTE },
+
+        { 0x6118, KEY_UP },
+        { 0x6119, KEY_DOWN },
+        { 0x611a, KEY_LEFT },
+        { 0x611b, KEY_RIGHT },
+
+        { 0x611c, KEY_RED },
+        { 0x611d, KEY_GREEN },
+        { 0x611e, KEY_YELLOW },
+        { 0x611f, KEY_BLUE },
+};
+
+struct ir_scancode_table ir_codes_kworld_315u_table = {
+        .scan = ir_codes_kworld_315u,
+        .size = ARRAY_SIZE(ir_codes_kworld_315u),
+        .ir_type = IR_TYPE_NEC,
+};
+EXPORT_SYMBOL_GPL(ir_codes_kworld_315u_table);
diff --git a/drivers/media/IR/ir-keytable.c b/drivers/media/IR/ir-keytable.c
index b521ed9d6e2e..0903f539bf68 100644
--- a/drivers/media/IR/ir-keytable.c
+++ b/drivers/media/IR/ir-keytable.c
@@ -65,7 +65,7 @@ exit:
  * In order to reduce the quantity of table resizes, it has a minimum
  * table size of IR_TAB_MIN_SIZE.
  */
-int ir_roundup_tablesize(int n_elems)
+static int ir_roundup_tablesize(int n_elems)
 {
         size_t size;
 
@@ -81,7 +81,6 @@ int ir_roundup_tablesize(int n_elems)
 
         return n_elems;
 }
-EXPORT_SYMBOL_GPL(ir_roundup_tablesize);
 
 /**
  * ir_copy_table() - copies a keytable, discarding the unused entries
@@ -89,9 +88,11 @@ EXPORT_SYMBOL_GPL(ir_roundup_tablesize);
  * @origin:     origin table
  *
  * Copies all entries where the keycode is not KEY_UNKNOWN/KEY_RESERVED
+ * Also copies table size and table protocol.
+ * NOTE: It shouldn't copy the lock field
  */
 
-int ir_copy_table(struct ir_scancode_table *destin,
+static int ir_copy_table(struct ir_scancode_table *destin,
                  const struct ir_scancode_table *origin)
 {
         int i, j = 0;
@@ -105,12 +106,12 @@ int ir_copy_table(struct ir_scancode_table *destin,
                 j++;
         }
         destin->size = j;
+        destin->ir_type = origin->ir_type;
 
         IR_dprintk(1, "Copied %d scancodes to the new keycode table\n", destin->size);
 
         return 0;
 }
-EXPORT_SYMBOL_GPL(ir_copy_table);
 
 /**
  * ir_getkeycode() - get a keycode at the evdev scancode ->keycode table
@@ -184,18 +185,14 @@ static void ir_delete_key(struct ir_scancode_table *rc_tab, int elem)
         int newsize = rc_tab->size - 1;
         int resize = ir_is_resize_needed(rc_tab, newsize);
         struct ir_scancode *oldkeymap = rc_tab->scan;
-        struct ir_scancode *newkeymap;
+        struct ir_scancode *newkeymap = NULL;
 
-        if (resize) {
+        if (resize)
                 newkeymap = kzalloc(ir_roundup_tablesize(newsize) *
                                     sizeof(*newkeymap), GFP_ATOMIC);
 
-                /* There's no memory for resize. Keep the old table */
-                if (!newkeymap)
-                        resize = 0;
-        }
-
-        if (!resize) {
+        /* There's no memory for resize. Keep the old table */
+        if (!resize || !newkeymap) {
                 newkeymap = oldkeymap;
 
                 /* We'll modify the live table. Lock it */
@@ -399,12 +396,14 @@ EXPORT_SYMBOL_GPL(ir_g_keycode_from_table);
  * @input_dev:  the struct input_dev descriptor of the device
  * @rc_tab:     the struct ir_scancode_table table of scancode/keymap
  *
- * This routine is used to initialize the input infrastructure to work with
- * an IR.
- * It should be called before registering the IR device.
+ * This routine is used to initialize the input infrastructure
+ * to work with an IR.
+ * It will register the input/evdev interface for the device and
+ * register the syfs code for IR class
  */
 int ir_input_register(struct input_dev *input_dev,
-                      struct ir_scancode_table *rc_tab)
+                      const struct ir_scancode_table *rc_tab,
+                      const struct ir_dev_props *props)
 {
         struct ir_input_dev *ir_dev;
         struct ir_scancode  *keymap    = rc_tab->scan;
@@ -417,19 +416,22 @@ int ir_input_register(struct input_dev *input_dev,
         if (!ir_dev)
                 return -ENOMEM;
 
-        spin_lock_init(&rc_tab->lock);
+        spin_lock_init(&ir_dev->rc_tab.lock);
 
         ir_dev->rc_tab.size = ir_roundup_tablesize(rc_tab->size);
         ir_dev->rc_tab.scan = kzalloc(ir_dev->rc_tab.size *
                                     sizeof(struct ir_scancode), GFP_KERNEL);
-        if (!ir_dev->rc_tab.scan)
+        if (!ir_dev->rc_tab.scan) {
+                kfree(ir_dev);
                 return -ENOMEM;
+        }
 
         IR_dprintk(1, "Allocated space for %d keycode entries (%zd bytes)\n",
                 ir_dev->rc_tab.size,
                 ir_dev->rc_tab.size * sizeof(ir_dev->rc_tab.scan));
 
         ir_copy_table(&ir_dev->rc_tab, rc_tab);
+        ir_dev->props = props;
 
         /* set the bits for the keys */
         IR_dprintk(1, "key map size: %d\n", rc_tab->size);
@@ -447,16 +449,31 @@ int ir_input_register(struct input_dev *input_dev,
         input_set_drvdata(input_dev, ir_dev);
 
         rc = input_register_device(input_dev);
+        if (rc < 0)
+                goto err;
+
+        rc = ir_register_class(input_dev);
         if (rc < 0) {
-                kfree(rc_tab->scan);
-                kfree(ir_dev);
-                input_set_drvdata(input_dev, NULL);
+                input_unregister_device(input_dev);
+                goto err;
         }
 
+        return 0;
+
+err:
+        kfree(rc_tab->scan);
+        kfree(ir_dev);
+        input_set_drvdata(input_dev, NULL);
         return rc;
 }
 EXPORT_SYMBOL_GPL(ir_input_register);
 
+/**
+ * ir_input_unregister() - unregisters IR and frees resources
+ * @input_dev:  the struct input_dev descriptor of the device
+
+ * This routine is used to free memory and de-register interfaces.
+ */
 void ir_input_unregister(struct input_dev *dev)
 {
         struct ir_input_dev *ir_dev = input_get_drvdata(dev);
@@ -472,6 +489,8 @@ void ir_input_unregister(struct input_dev *dev)
         kfree(rc_tab->scan);
         rc_tab->scan = NULL;
 
+        ir_unregister_class(dev);
+
         kfree(ir_dev);
         input_unregister_device(dev);
 }
diff --git a/drivers/media/IR/ir-sysfs.c b/drivers/media/IR/ir-sysfs.c
new file mode 100644
index 000000000000..bf5fbcd84238
--- /dev/null
+++ b/drivers/media/IR/ir-sysfs.c
@@ -0,0 +1,211 @@
+/* ir-register.c - handle IR scancode->keycode tables
+ *
+ * Copyright (C) 2009 by Mauro Carvalho Chehab <mchehab@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation version 2 of the License.
+ *
+ *  This program is distributed in the hope that 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/input.h>
+#include <linux/device.h>
+#include <media/ir-core.h>
+
+#define IRRCV_NUM_DEVICES       256
+
+/* bit array to represent IR sysfs device number */
+static unsigned long ir_core_dev_number;
+
+/* class for /sys/class/irrcv */
+static struct class *ir_input_class;
+
+/**
+ * show_protocol() - shows the current IR protocol
+ * @d:          the device descriptor
+ * @mattr:      the device attribute struct (unused)
+ * @buf:        a pointer to the output buffer
+ *
+ * This routine is a callback routine for input read the IR protocol type.
+ * it is trigged by reading /sys/class/irrcv/irrcv?/current_protocol.
+ * It returns the protocol name, as understood by the driver.
+ */
+static ssize_t show_protocol(struct device *d,
+                             struct device_attribute *mattr, char *buf)
+{
+        char *s;
+        struct ir_input_dev *ir_dev = dev_get_drvdata(d);
+        u64 ir_type = ir_dev->rc_tab.ir_type;
+
+        IR_dprintk(1, "Current protocol is %lld\n", (long long)ir_type);
+
+        /* FIXME: doesn't support multiple protocols at the same time */
+        if (ir_type == IR_TYPE_UNKNOWN)
+                s = "Unknown";
+        else if (ir_type == IR_TYPE_RC5)
+                s = "RC-5";
+        else if (ir_type == IR_TYPE_PD)
+                s = "Pulse/distance";
+        else if (ir_type == IR_TYPE_NEC)
+                s = "NEC";
+        else
+                s = "Other";
+
+        return sprintf(buf, "%s\n", s);
+}
+
+/**
+ * store_protocol() - shows the current IR protocol
+ * @d:          the device descriptor
+ * @mattr:      the device attribute struct (unused)
+ * @buf:        a pointer to the input buffer
+ * @len:        length of the input buffer
+ *
+ * This routine is a callback routine for changing the IR protocol type.
+ * it is trigged by reading /sys/class/irrcv/irrcv?/current_protocol.
+ * It changes the IR the protocol name, if the IR type is recognized
+ * by the driver.
+ * If an unknown protocol name is used, returns -EINVAL.
+ */
+static ssize_t store_protocol(struct device *d,
+                              struct device_attribute *mattr,
+                              const char *data,
+                              size_t len)
+{
+        struct ir_input_dev *ir_dev = dev_get_drvdata(d);
+        u64 ir_type = IR_TYPE_UNKNOWN;
+        int rc = -EINVAL;
+        unsigned long flags;
+        char *buf;
+
+        buf = strsep((char **) &data, "\n");
+
+        if (!strcasecmp(buf, "rc-5"))
+                ir_type = IR_TYPE_RC5;
+        else if (!strcasecmp(buf, "pd"))
+                ir_type = IR_TYPE_PD;
+        else if (!strcasecmp(buf, "nec"))
+                ir_type = IR_TYPE_NEC;
+
+        if (ir_type == IR_TYPE_UNKNOWN) {
+                IR_dprintk(1, "Error setting protocol to %lld\n",
+                           (long long)ir_type);
+                return -EINVAL;
+        }
+
+        if (ir_dev->props && ir_dev->props->change_protocol)
+                rc = ir_dev->props->change_protocol(ir_dev->props->priv,
+                                                    ir_type);
+
+        if (rc < 0) {
+                IR_dprintk(1, "Error setting protocol to %lld\n",
+                           (long long)ir_type);
+                return -EINVAL;
+        }
+
+        spin_lock_irqsave(&ir_dev->rc_tab.lock, flags);
+        ir_dev->rc_tab.ir_type = ir_type;
+        spin_unlock_irqrestore(&ir_dev->rc_tab.lock, flags);
+
+        IR_dprintk(1, "Current protocol is %lld\n",
+                   (long long)ir_type);
+
+        return len;
+}
+
+/*
+ * Static device attribute struct with the sysfs attributes for IR's
+ */
+static DEVICE_ATTR(current_protocol, S_IRUGO | S_IWUSR,
+                   show_protocol, store_protocol);
+
+static struct attribute *ir_dev_attrs[] = {
+        &dev_attr_current_protocol.attr,
+        NULL,
+};
+
+/**
+ * ir_register_class() - creates the sysfs for /sys/class/irrcv/irrcv?
+ * @input_dev:  the struct input_dev descriptor of the device
+ *
+ * This routine is used to register the syfs code for IR class
+ */
+int ir_register_class(struct input_dev *input_dev)
+{
+        int rc;
+        struct kobject *kobj;
+
+        struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
+        int devno = find_first_zero_bit(&ir_core_dev_number,
+                                        IRRCV_NUM_DEVICES);
+
+        if (unlikely(devno < 0))
+                return devno;
+
+        ir_dev->attr.attrs = ir_dev_attrs;
+        ir_dev->class_dev = device_create(ir_input_class, NULL,
+                                          input_dev->dev.devt, ir_dev,
+                                          "irrcv%d", devno);
+        kobj = &ir_dev->class_dev->kobj;
+
+        printk(KERN_WARNING "Creating IR device %s\n", kobject_name(kobj));
+        rc = sysfs_create_group(kobj, &ir_dev->attr);
+        if (unlikely(rc < 0)) {
+                device_destroy(ir_input_class, input_dev->dev.devt);
+                return -ENOMEM;
+        }
+
+        ir_dev->devno = devno;
+        set_bit(devno, &ir_core_dev_number);
+
+        return 0;
+};
+
+/**
+ * ir_unregister_class() - removes the sysfs for sysfs for
+ *                         /sys/class/irrcv/irrcv?
+ * @input_dev:  the struct input_dev descriptor of the device
+ *
+ * This routine is used to unregister the syfs code for IR class
+ */
+void ir_unregister_class(struct input_dev *input_dev)
+{
+        struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
+        struct kobject *kobj;
+
+        clear_bit(ir_dev->devno, &ir_core_dev_number);
+
+        kobj = &ir_dev->class_dev->kobj;
+
+        sysfs_remove_group(kobj, &ir_dev->attr);
+        device_destroy(ir_input_class, input_dev->dev.devt);
+
+        kfree(ir_dev->attr.name);
+}
+
+/*
+ * Init/exit code for the module. Basically, creates/removes /sys/class/irrcv
+ */
+
+static int __init ir_core_init(void)
+{
+        ir_input_class = class_create(THIS_MODULE, "irrcv");
+        if (IS_ERR(ir_input_class)) {
+                printk(KERN_ERR "ir_core: unable to register irrcv class\n");
+                return PTR_ERR(ir_input_class);
+        }
+
+        return 0;
+}
+
+static void __exit ir_core_exit(void)
+{
+        class_destroy(ir_input_class);
+}
+
+module_init(ir_core_init);
+module_exit(ir_core_exit);