V4L/DVB: ir-core: centralize sysfs raw decoder enabling/disabling

With the current logic, each raw decoder needs to add a copy of the exact
same sysfs code. This is both unnecessary and also means that (re)loading
an IR driver after raw decoder modules have been loaded won't work as
expected.

This patch moves that logic into ir-raw-event and adds a single sysfs
file per device.

Reading that file returns something like:

	"rc5 [rc6] nec jvc [sony]"

(with enabled protocols in [] brackets)

Writing either "+protocol" or "-protocol" to that file will
enable or disable the according protocol decoder.

An additional benefit is that the disabling of a decoder will be
remembered across module removal/insertion so a previously
disabled decoder won't suddenly be activated again. The default
setting is to enable all decoders.

This is also necessary for the next patch which moves even more decoder
state into the central raw decoding structs.

Signed-off-by: David Härdeman <david@hardeman.nu>
Acked-by: Jarod Wilson <jarod@redhat.com>
Tested-by: Jarod Wilson <jarod@redhat.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

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;