1 files changed, 148 insertions, 104 deletions

diff --git a/drivers/media/IR/ir-sysfs.c b/drivers/media/IR/ir-sysfs.c
index 2098dd1488e0..005621d067f0 100644
--- a/drivers/media/IR/ir-sysfs.c
+++ b/drivers/media/IR/ir-sysfs.c
@@ -34,122 +34,178 @@ static struct class ir_input_class = {
 };
 
 /**
- * show_protocol() - shows the current IR protocol
+ * show_protocols() - shows the current IR protocol(s)
  * @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/rc/rc?/current_protocol.
- * It returns the protocol name, as understood by the driver.
+ * This routine is a callback routine for input read the IR protocol type(s).
+ * it is trigged by reading /sys/class/rc/rc?/protocols.
+ * It returns the protocol names of supported protocols.
+ * Enabled protocols are printed in brackets.
  */
-static ssize_t show_protocol(struct device *d,
-                             struct device_attribute *mattr, char *buf)
+static ssize_t show_protocols(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_NEC)
-                s = "nec";
-        else if (ir_type == IR_TYPE_RC6)
-                s = "rc6";
-        else if (ir_type == IR_TYPE_JVC)
-                s = "jvc";
-        else if (ir_type == IR_TYPE_SONY)
-                s = "sony";
-        else
-                s = "other";
+        u64 allowed, enabled;
+        char *tmp = buf;
+
+        if (ir_dev->props->driver_type == RC_DRIVER_SCANCODE) {
+                enabled = ir_dev->rc_tab.ir_type;
+                allowed = ir_dev->props->allowed_protos;
+        } else {
+                enabled = ir_dev->raw->enabled_protocols;
+                allowed = ir_raw_get_allowed_protocols();
+        }
 
-        return sprintf(buf, "%s\n", s);
+        IR_dprintk(1, "allowed - 0x%llx, enabled - 0x%llx\n",
+                   (long long)allowed,
+                   (long long)enabled);
+
+        if (allowed & enabled & IR_TYPE_UNKNOWN)
+                tmp += sprintf(tmp, "[unknown] ");
+        else if (allowed & IR_TYPE_UNKNOWN)
+                tmp += sprintf(tmp, "unknown ");
+
+        if (allowed & enabled & IR_TYPE_RC5)
+                tmp += sprintf(tmp, "[rc5] ");
+        else if (allowed & IR_TYPE_RC5)
+                tmp += sprintf(tmp, "rc5 ");
+
+        if (allowed & enabled & IR_TYPE_NEC)
+                tmp += sprintf(tmp, "[nec] ");
+        else if (allowed & IR_TYPE_NEC)
+                tmp += sprintf(tmp, "nec ");
+
+        if (allowed & enabled & IR_TYPE_RC6)
+                tmp += sprintf(tmp, "[rc6] ");
+        else if (allowed & IR_TYPE_RC6)
+                tmp += sprintf(tmp, "rc6 ");
+
+        if (allowed & enabled & IR_TYPE_JVC)
+                tmp += sprintf(tmp, "[jvc] ");
+        else if (allowed & IR_TYPE_JVC)
+                tmp += sprintf(tmp, "jvc ");
+
+        if (allowed & enabled & IR_TYPE_SONY)
+                tmp += sprintf(tmp, "[sony] ");
+        else if (allowed & IR_TYPE_SONY)
+                tmp += sprintf(tmp, "sony ");
+
+        if (tmp != buf)
+                tmp--;
+        *tmp = '\n';
+        return tmp + 1 - buf;
 }
 
 /**
- * store_protocol() - shows the current IR protocol
+ * store_protocols() - changes the current IR protocol(s)
  * @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/rc/rc?/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.
+ * It is trigged by writing to /sys/class/rc/rc?/protocols.
+ * Writing "+proto" will add a protocol to the list of enabled protocols.
+ * Writing "-proto" will remove a protocol from the list of enabled protocols.
+ * Writing "proto" will enable only "proto".
+ * Returns -EINVAL if an invalid protocol combination or unknown protocol name
+ * is used, otherwise @len.
  */
-static ssize_t store_protocol(struct device *d,
-                              struct device_attribute *mattr,
-                              const char *data,
-                              size_t len)
+static ssize_t store_protocols(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 = 0;
-        int rc = -EINVAL;
+        bool enable, disable;
+        const char *tmp;
+        u64 type;
+        u64 mask;
+        int rc;
         unsigned long flags;
-        char *buf;
-
-        while ((buf = strsep((char **) &data, " \n")) != NULL) {
-                if (!strcasecmp(buf, "rc-5") || !strcasecmp(buf, "rc5"))
-                        ir_type |= IR_TYPE_RC5;
-                if (!strcasecmp(buf, "nec"))
-                        ir_type |= IR_TYPE_NEC;
-                if (!strcasecmp(buf, "jvc"))
-                        ir_type |= IR_TYPE_JVC;
-                if (!strcasecmp(buf, "sony"))
-                        ir_type |= IR_TYPE_SONY;
+
+        tmp = skip_spaces(data);
+
+        if (*tmp == '+') {
+                enable = true;
+                disable = false;
+                tmp++;
+        } else if (*tmp == '-') {
+                enable = false;
+                disable = true;
+                tmp++;
+        } else {
+                enable = false;
+                disable = false;
         }
 
-        if (!ir_type) {
+        if (!strncasecmp(tmp, "unknown", 7)) {
+                tmp += 7;
+                mask = IR_TYPE_UNKNOWN;
+        } else if (!strncasecmp(tmp, "rc5", 3)) {
+                tmp += 3;
+                mask = IR_TYPE_RC5;
+        } else if (!strncasecmp(tmp, "nec", 3)) {
+                tmp += 3;
+                mask = IR_TYPE_NEC;
+        } else if (!strncasecmp(tmp, "rc6", 3)) {
+                tmp += 3;
+                mask = IR_TYPE_RC6;
+        } else if (!strncasecmp(tmp, "jvc", 3)) {
+                tmp += 3;
+                mask = IR_TYPE_JVC;
+        } else if (!strncasecmp(tmp, "sony", 4)) {
+                tmp += 4;
+                mask = IR_TYPE_SONY;
+        } else {
                 IR_dprintk(1, "Unknown protocol\n");
                 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);
+        tmp = skip_spaces(tmp);
+        if (*tmp != '\0') {
+                IR_dprintk(1, "Invalid trailing characters\n");
                 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);
+        if (ir_dev->props->driver_type == RC_DRIVER_SCANCODE)
+                type = ir_dev->rc_tab.ir_type;
+        else
+                type = ir_dev->raw->enabled_protocols;
 
-        IR_dprintk(1, "Current protocol(s) is(are) %lld\n",
-                   (long long)ir_type);
+        if (enable)
+                type |= mask;
+        else if (disable)
+                type &= ~mask;
+        else
+                type = mask;
 
-        return len;
-}
+        if (ir_dev->props && ir_dev->props->change_protocol) {
+                rc = ir_dev->props->change_protocol(ir_dev->props->priv,
+                                                    type);
+                if (rc < 0) {
+                        IR_dprintk(1, "Error setting protocols to 0x%llx\n",
+                                   (long long)type);
+                        return -EINVAL;
+                }
+        }
 
-static ssize_t show_supported_protocols(struct device *d,
-                             struct device_attribute *mattr, char *buf)
-{
-        char *orgbuf = buf;
-        struct ir_input_dev *ir_dev = dev_get_drvdata(d);
+        if (ir_dev->props->driver_type == RC_DRIVER_SCANCODE) {
+                spin_lock_irqsave(&ir_dev->rc_tab.lock, flags);
+                ir_dev->rc_tab.ir_type = type;
+                spin_unlock_irqrestore(&ir_dev->rc_tab.lock, flags);
+        } else {
+                ir_dev->raw->enabled_protocols = type;
+        }
 
-        /* FIXME: doesn't support multiple protocols at the same time */
-        if (ir_dev->props->allowed_protos == IR_TYPE_UNKNOWN)
-                buf += sprintf(buf, "unknown ");
-        if (ir_dev->props->allowed_protos & IR_TYPE_RC5)
-                buf += sprintf(buf, "rc-5 ");
-        if (ir_dev->props->allowed_protos & IR_TYPE_NEC)
-                buf += sprintf(buf, "nec ");
-        if (buf == orgbuf)
-                buf += sprintf(buf, "other ");
 
-        buf += sprintf(buf - 1, "\n");
+        IR_dprintk(1, "Current protocol(s): 0x%llx\n",
+                   (long long)type);
 
-        return buf - orgbuf;
+        return len;
 }
 
 #define ADD_HOTPLUG_VAR(fmt, val...)                                    \
@@ -159,7 +215,7 @@ static ssize_t show_supported_protocols(struct device *d,
                         return err;                                     \
         } while (0)
 
-static int ir_dev_uevent(struct device *device, struct kobj_uevent_env *env)
+static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env)
 {
         struct ir_input_dev *ir_dev = dev_get_drvdata(device);
 
@@ -174,34 +230,26 @@ static int ir_dev_uevent(struct device *device, struct kobj_uevent_env *env)
 /*
  * Static device attribute struct with the sysfs attributes for IR's
  */
-static DEVICE_ATTR(protocol, S_IRUGO | S_IWUSR,
-                   show_protocol, store_protocol);
-
-static DEVICE_ATTR(supported_protocols, S_IRUGO | S_IWUSR,
-                   show_supported_protocols, NULL);
+static DEVICE_ATTR(protocols, S_IRUGO | S_IWUSR,
+                   show_protocols, store_protocols);
 
-static struct attribute *ir_hw_dev_attrs[] = {
-        &dev_attr_protocol.attr,
-        &dev_attr_supported_protocols.attr,
+static struct attribute *rc_dev_attrs[] = {
+        &dev_attr_protocols.attr,
         NULL,
 };
 
-static struct attribute_group ir_hw_dev_attr_grp = {
-        .attrs  = ir_hw_dev_attrs,
+static struct attribute_group rc_dev_attr_grp = {
+        .attrs  = rc_dev_attrs,
 };
 
-static const struct attribute_group *ir_hw_dev_attr_groups[] = {
-        &ir_hw_dev_attr_grp,
+static const struct attribute_group *rc_dev_attr_groups[] = {
+        &rc_dev_attr_grp,
         NULL
 };
 
 static struct device_type rc_dev_type = {
-        .groups         = ir_hw_dev_attr_groups,
-        .uevent         = ir_dev_uevent,
-};
-
-static struct device_type ir_raw_dev_type = {
-        .uevent         = ir_dev_uevent,
+        .groups         = rc_dev_attr_groups,
+        .uevent         = rc_dev_uevent,
 };
 
 /**
@@ -221,11 +269,7 @@ int ir_register_class(struct input_dev *input_dev)
         if (unlikely(devno < 0))
                 return devno;
 
-        if (ir_dev->props) {
-                if (ir_dev->props->driver_type == RC_DRIVER_SCANCODE)
-                        ir_dev->dev.type = &rc_dev_type;
-        } else
-                ir_dev->dev.type = &ir_raw_dev_type;
+        ir_dev->dev.type = &rc_dev_type;
 
         ir_dev->dev.class = &ir_input_class;
         ir_dev->dev.parent = input_dev->dev.parent;