GUI: Fix Tomato RAF theme for all builds. Compilation typo.

[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / media / IR / ir-sysfs.c

/* ir-sysfs.c - sysfs interface for RC devices (/sys/class/rc)
 *
 * Copyright (C) 2009-2010 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/slab.h>
#include <linux/input.h>
#include <linux/device.h>
#include "ir-core-priv.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/rc */
static char *ir_devnode(struct device *dev, mode_t *mode)
{
        return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev));
}

static struct class ir_input_class = {
        .name           = "rc",
        .devnode        = ir_devnode,
};

static struct {
        u64     type;
        char    *name;
} proto_names[] = {
        { IR_TYPE_UNKNOWN,      "unknown"       },
        { IR_TYPE_RC5,          "rc-5"          },
        { IR_TYPE_NEC,          "nec"           },
        { IR_TYPE_RC6,          "rc-6"          },
        { IR_TYPE_JVC,          "jvc"           },
        { IR_TYPE_SONY,         "sony"          },
        { IR_TYPE_LIRC,         "lirc"          },
};

#define PROTO_NONE      "none"

/**
 * 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(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_protocols(struct device *d,
                              struct device_attribute *mattr, char *buf)
{
        struct ir_input_dev *ir_dev = dev_get_drvdata(d);
        u64 allowed, enabled;
        char *tmp = buf;
        int i;

        if (ir_dev->props && ir_dev->props->driver_type == RC_DRIVER_SCANCODE) {
                enabled = ir_dev->rc_tab.ir_type;
                allowed = ir_dev->props->allowed_protos;
        } else if (ir_dev->raw) {
                enabled = ir_dev->raw->enabled_protocols;
                allowed = ir_raw_get_allowed_protocols();
        } else
                return sprintf(tmp, "[builtin]\n");

        IR_dprintk(1, "allowed - 0x%llx, enabled - 0x%llx\n",
                   (long long)allowed,
                   (long long)enabled);

        for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
                if (allowed & enabled & proto_names[i].type)
                        tmp += sprintf(tmp, "[%s] ", proto_names[i].name);
                else if (allowed & proto_names[i].type)
                        tmp += sprintf(tmp, "%s ", proto_names[i].name);
        }

        if (tmp != buf)
                tmp--;
        *tmp = '\n';
        return tmp + 1 - buf;
}

/**
 * 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 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".
 * Writing "none" will disable all protocols.
 * Returns -EINVAL if an invalid protocol combination or unknown protocol name
 * is used, otherwise @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);
        bool enable, disable;
        const char *tmp;
        u64 type;
        u64 mask;
        int rc, i, count = 0;
        unsigned long flags;

        if (ir_dev->props && ir_dev->props->driver_type == RC_DRIVER_SCANCODE)
                type = ir_dev->rc_tab.ir_type;
        else if (ir_dev->raw)
                type = ir_dev->raw->enabled_protocols;
        else {
                IR_dprintk(1, "Protocol switching not supported\n");
                return -EINVAL;
        }

        while ((tmp = strsep((char **) &data, " \n")) != NULL) {
                if (!*tmp)
                        break;

                if (*tmp == '+') {
                        enable = true;
                        disable = false;
                        tmp++;
                } else if (*tmp == '-') {
                        enable = false;
                        disable = true;
                        tmp++;
                } else {
                        enable = false;
                        disable = false;
                }

                if (!enable && !disable && !strncasecmp(tmp, PROTO_NONE, sizeof(PROTO_NONE))) {
                        tmp += sizeof(PROTO_NONE);
                        mask = 0;
                        count++;
                } else {
                        for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
                                if (!strncasecmp(tmp, proto_names[i].name, strlen(proto_names[i].name))) {
                                        tmp += strlen(proto_names[i].name);
                                        mask = proto_names[i].type;
                                        break;
                                }
                        }
                        if (i == ARRAY_SIZE(proto_names)) {
                                IR_dprintk(1, "Unknown protocol: '%s'\n", tmp);
                                return -EINVAL;
                        }
                        count++;
                }

                if (enable)
                        type |= mask;
                else if (disable)
                        type &= ~mask;
                else
                        type = mask;
        }

        if (!count) {
                IR_dprintk(1, "Protocol not specified\n");
                return -EINVAL;
        }

        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;
                }
        }

        if (ir_dev->props && 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;
        }

        IR_dprintk(1, "Current protocol(s): 0x%llx\n",
                   (long long)type);

        return len;
}

#define ADD_HOTPLUG_VAR(fmt, val...)                                    \
        do {                                                            \
                int err = add_uevent_var(env, fmt, val);                \
                if (err)                                                \
                        return err;                                     \
        } while (0)

static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env)
{
        struct ir_input_dev *ir_dev = dev_get_drvdata(device);

        if (ir_dev->rc_tab.name)
                ADD_HOTPLUG_VAR("NAME=%s", ir_dev->rc_tab.name);
        if (ir_dev->driver_name)
                ADD_HOTPLUG_VAR("DRV_NAME=%s", ir_dev->driver_name);

        return 0;
}

/*
 * Static device attribute struct with the sysfs attributes for IR's
 */
static DEVICE_ATTR(protocols, S_IRUGO | S_IWUSR,
                   show_protocols, store_protocols);

static struct attribute *rc_dev_attrs[] = {
        &dev_attr_protocols.attr,
        NULL,
};

static struct attribute_group rc_dev_attr_grp = {
        .attrs  = rc_dev_attrs,
};

static const struct attribute_group *rc_dev_attr_groups[] = {
        &rc_dev_attr_grp,
        NULL
};

static struct device_type rc_dev_type = {
        .groups         = rc_dev_attr_groups,
        .uevent         = rc_dev_uevent,
};

/**
 * ir_register_class() - creates the sysfs for /sys/class/rc/rc?
 * @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;
        const char *path;
        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->dev.type = &rc_dev_type;

        ir_dev->dev.class = &ir_input_class;
        ir_dev->dev.parent = input_dev->dev.parent;
        dev_set_name(&ir_dev->dev, "rc%d", devno);
        dev_set_drvdata(&ir_dev->dev, ir_dev);
        rc = device_register(&ir_dev->dev);
        if (rc)
                return rc;


        input_dev->dev.parent = &ir_dev->dev;
        rc = input_register_device(input_dev);
        if (rc < 0) {
                device_del(&ir_dev->dev);
                return rc;
        }

        __module_get(THIS_MODULE);

        path = kobject_get_path(&ir_dev->dev.kobj, GFP_KERNEL);
        printk(KERN_INFO "%s: %s as %s\n",
                dev_name(&ir_dev->dev),
                input_dev->name ? input_dev->name : "Unspecified device",
                path ? path : "N/A");
        kfree(path);

        ir_dev->devno = devno;
        set_bit(devno, &ir_core_dev_number);

        return 0;
};

/**
 * ir_unregister_class() - removes the sysfs for sysfs for
 *                         /sys/class/rc/rc?
 * @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);

        clear_bit(ir_dev->devno, &ir_core_dev_number);
        input_unregister_device(input_dev);
        device_del(&ir_dev->dev);

        module_put(THIS_MODULE);
}

/*
 * Init/exit code for the module. Basically, creates/removes /sys/class/rc
 */

static int __init ir_core_init(void)
{
        int rc = class_register(&ir_input_class);
        if (rc) {
                printk(KERN_ERR "ir_core: unable to register rc class\n");
                return rc;
        }

        /* Initialize/load the decoders/keymap code that will be used */
        ir_raw_init();
        ir_rcmap_init();

        return 0;
}

static void __exit ir_core_exit(void)
{
        class_unregister(&ir_input_class);
        ir_rcmap_cleanup();
}

module_init(ir_core_init);
module_exit(ir_core_exit);