drivers/media/IR/ir-sysfs.c

   1 /* ir-sysfs.c - sysfs interface for RC devices (/sys/class/rc)
   2  *
   3  * Copyright (C) 2009-2010 by Mauro Carvalho Chehab <mchehab@redhat.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation version 2 of the License.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  */
  14
  15 #include <linux/slab.h>
  16 #include <linux/input.h>
  17 #include <linux/device.h>
  18 #include "ir-core-priv.h"
  19
  20 #define IRRCV_NUM_DEVICES       256
  21
  22 /* bit array to represent IR sysfs device number */
  23 static unsigned long ir_core_dev_number;
  24
  25 /* class for /sys/class/rc */
  26 static char *ir_devnode(struct device *dev, mode_t *mode)
  27 {
  28         return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev));
  29 }
  30
  31 static struct class ir_input_class = {
  32         .name           = "rc",
  33         .devnode        = ir_devnode,
  34 };
  35
  36 /**
  37  * show_protocol() - shows the current IR protocol
  38  * @d:          the device descriptor
  39  * @mattr:      the device attribute struct (unused)
  40  * @buf:        a pointer to the output buffer
  41  *
  42  * This routine is a callback routine for input read the IR protocol type.
  43  * it is trigged by reading /sys/class/rc/rc?/current_protocol.
  44  * It returns the protocol name, as understood by the driver.
  45  */
  46 static ssize_t show_protocol(struct device *d,
  47                              struct device_attribute *mattr, char *buf)
  48 {
  49         char *s;
  50         struct ir_input_dev *ir_dev = dev_get_drvdata(d);
  51         u64 ir_type = ir_dev->rc_tab.ir_type;
  52
  53         IR_dprintk(1, "Current protocol is %lld\n", (long long)ir_type);
  54
  55         /* FIXME: doesn't support multiple protocols at the same time */
  56         if (ir_type == IR_TYPE_UNKNOWN)
  57                 s = "Unknown";
  58         else if (ir_type == IR_TYPE_RC5)
  59                 s = "rc-5";
  60         else if (ir_type == IR_TYPE_PD)
  61                 s = "pulse-distance";
  62         else if (ir_type == IR_TYPE_NEC)
  63                 s = "nec";
  64         else if (ir_type == IR_TYPE_RC6)
  65                 s = "rc6";
  66         else if (ir_type == IR_TYPE_JVC)
  67                 s = "jvc";
  68         else if (ir_type == IR_TYPE_SONY)
  69                 s = "sony";
  70         else
  71                 s = "other";
  72
  73         return sprintf(buf, "%s\n", s);
  74 }
  75
  76 /**
  77  * store_protocol() - shows the current IR protocol
  78  * @d:          the device descriptor
  79  * @mattr:      the device attribute struct (unused)
  80  * @buf:        a pointer to the input buffer
  81  * @len:        length of the input buffer
  82  *
  83  * This routine is a callback routine for changing the IR protocol type.
  84  * it is trigged by reading /sys/class/rc/rc?/current_protocol.
  85  * It changes the IR the protocol name, if the IR type is recognized
  86  * by the driver.
  87  * If an unknown protocol name is used, returns -EINVAL.
  88  */
  89 static ssize_t store_protocol(struct device *d,
  90                               struct device_attribute *mattr,
  91                               const char *data,
  92                               size_t len)
  93 {
  94         struct ir_input_dev *ir_dev = dev_get_drvdata(d);
  95         u64 ir_type = 0;
  96         int rc = -EINVAL;
  97         unsigned long flags;
  98         char *buf;
  99
 100         while ((buf = strsep((char **) &data, " \n")) != NULL) {
 101                 if (!strcasecmp(buf, "rc-5") || !strcasecmp(buf, "rc5"))
 102                         ir_type |= IR_TYPE_RC5;
 103                 if (!strcasecmp(buf, "pd") || !strcasecmp(buf, "pulse-distance"))
 104                         ir_type |= IR_TYPE_PD;
 105                 if (!strcasecmp(buf, "nec"))
 106                         ir_type |= IR_TYPE_NEC;
 107                 if (!strcasecmp(buf, "jvc"))
 108                         ir_type |= IR_TYPE_JVC;
 109                 if (!strcasecmp(buf, "sony"))
 110                         ir_type |= IR_TYPE_SONY;
 111         }
 112
 113         if (!ir_type) {
 114                 IR_dprintk(1, "Unknown protocol\n");
 115                 return -EINVAL;
 116         }
 117
 118         if (ir_dev->props && ir_dev->props->change_protocol)
 119                 rc = ir_dev->props->change_protocol(ir_dev->props->priv,
 120                                                     ir_type);
 121
 122         if (rc < 0) {
 123                 IR_dprintk(1, "Error setting protocol to %lld\n",
 124                            (long long)ir_type);
 125                 return -EINVAL;
 126         }
 127
 128         spin_lock_irqsave(&ir_dev->rc_tab.lock, flags);
 129         ir_dev->rc_tab.ir_type = ir_type;
 130         spin_unlock_irqrestore(&ir_dev->rc_tab.lock, flags);
 131
 132         IR_dprintk(1, "Current protocol(s) is(are) %lld\n",
 133                    (long long)ir_type);
 134
 135         return len;
 136 }
 137
 138 static ssize_t show_supported_protocols(struct device *d,
 139                              struct device_attribute *mattr, char *buf)
 140 {
 141         char *orgbuf = buf;
 142         struct ir_input_dev *ir_dev = dev_get_drvdata(d);
 143
 144         /* FIXME: doesn't support multiple protocols at the same time */
 145         if (ir_dev->props->allowed_protos == IR_TYPE_UNKNOWN)
 146                 buf += sprintf(buf, "unknown ");
 147         if (ir_dev->props->allowed_protos & IR_TYPE_RC5)
 148                 buf += sprintf(buf, "rc-5 ");
 149         if (ir_dev->props->allowed_protos & IR_TYPE_PD)
 150                 buf += sprintf(buf, "pulse-distance ");
 151         if (ir_dev->props->allowed_protos & IR_TYPE_NEC)
 152                 buf += sprintf(buf, "nec ");
 153         if (buf == orgbuf)
 154                 buf += sprintf(buf, "other ");
 155
 156         buf += sprintf(buf - 1, "\n");
 157
 158         return buf - orgbuf;
 159 }
 160
 161 #define ADD_HOTPLUG_VAR(fmt, val...)                                    \
 162         do {                                                            \
 163                 int err = add_uevent_var(env, fmt, val);                \
 164                 if (err)                                                \
 165                         return err;                                     \
 166         } while (0)
 167
 168 static int ir_dev_uevent(struct device *device, struct kobj_uevent_env *env)
 169 {
 170         struct ir_input_dev *ir_dev = dev_get_drvdata(device);
 171
 172         if (ir_dev->rc_tab.name)
 173                 ADD_HOTPLUG_VAR("NAME=%s", ir_dev->rc_tab.name);
 174         if (ir_dev->driver_name)
 175                 ADD_HOTPLUG_VAR("DRV_NAME=%s", ir_dev->driver_name);
 176
 177         return 0;
 178 }
 179
 180 /*
 181  * Static device attribute struct with the sysfs attributes for IR's
 182  */
 183 static DEVICE_ATTR(protocol, S_IRUGO | S_IWUSR,
 184                    show_protocol, store_protocol);
 185
 186 static DEVICE_ATTR(supported_protocols, S_IRUGO | S_IWUSR,
 187                    show_supported_protocols, NULL);
 188
 189 static struct attribute *ir_hw_dev_attrs[] = {
 190         &dev_attr_protocol.attr,
 191         &dev_attr_supported_protocols.attr,
 192         NULL,
 193 };
 194
 195 static struct attribute_group ir_hw_dev_attr_grp = {
 196         .attrs  = ir_hw_dev_attrs,
 197 };
 198
 199 static const struct attribute_group *ir_hw_dev_attr_groups[] = {
 200         &ir_hw_dev_attr_grp,
 201         NULL
 202 };
 203
 204 static struct device_type rc_dev_type = {
 205         .groups         = ir_hw_dev_attr_groups,
 206         .uevent         = ir_dev_uevent,
 207 };
 208
 209 static struct device_type ir_raw_dev_type = {
 210         .uevent         = ir_dev_uevent,
 211 };
 212
 213 /**
 214  * ir_register_class() - creates the sysfs for /sys/class/rc/rc?
 215  * @input_dev:  the struct input_dev descriptor of the device
 216  *
 217  * This routine is used to register the syfs code for IR class
 218  */
 219 int ir_register_class(struct input_dev *input_dev)
 220 {
 221         int rc;
 222         const char *path;
 223         struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
 224         int devno = find_first_zero_bit(&ir_core_dev_number,
 225                                         IRRCV_NUM_DEVICES);
 226
 227         if (unlikely(devno < 0))
 228                 return devno;
 229
 230         if (ir_dev->props->driver_type == RC_DRIVER_SCANCODE)
 231                 ir_dev->dev.type = &rc_dev_type;
 232         else
 233                 ir_dev->dev.type = &ir_raw_dev_type;
 234
 235         ir_dev->dev.class = &ir_input_class;
 236         ir_dev->dev.parent = input_dev->dev.parent;
 237         dev_set_name(&ir_dev->dev, "rc%d", devno);
 238         dev_set_drvdata(&ir_dev->dev, ir_dev);
 239         rc = device_register(&ir_dev->dev);
 240         if (rc)
 241                 return rc;
 242
 243
 244         input_dev->dev.parent = &ir_dev->dev;
 245         rc = input_register_device(input_dev);
 246         if (rc < 0) {
 247                 device_del(&ir_dev->dev);
 248                 return rc;
 249         }
 250
 251         __module_get(THIS_MODULE);
 252
 253         path = kobject_get_path(&ir_dev->dev.kobj, GFP_KERNEL);
 254         printk(KERN_INFO "%s: %s as %s\n",
 255                 dev_name(&ir_dev->dev),
 256                 input_dev->name ? input_dev->name : "Unspecified device",
 257                 path ? path : "N/A");
 258         kfree(path);
 259
 260         ir_dev->devno = devno;
 261         set_bit(devno, &ir_core_dev_number);
 262
 263         return 0;
 264 };
 265
 266 /**
 267  * ir_unregister_class() - removes the sysfs for sysfs for
 268  *                         /sys/class/rc/rc?
 269  * @input_dev:  the struct input_dev descriptor of the device
 270  *
 271  * This routine is used to unregister the syfs code for IR class
 272  */
 273 void ir_unregister_class(struct input_dev *input_dev)
 274 {
 275         struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
 276
 277         clear_bit(ir_dev->devno, &ir_core_dev_number);
 278         input_unregister_device(input_dev);
 279         device_del(&ir_dev->dev);
 280
 281         module_put(THIS_MODULE);
 282 }
 283
 284 /*
 285  * Init/exit code for the module. Basically, creates/removes /sys/class/rc
 286  */
 287
 288 static int __init ir_core_init(void)
 289 {
 290         int rc = class_register(&ir_input_class);
 291         if (rc) {
 292                 printk(KERN_ERR "ir_core: unable to register rc class\n");
 293                 return rc;
 294         }
 295
 296         /* Initialize/load the decoders/keymap code that will be used */
 297         ir_raw_init();
 298
 299         return 0;
 300 }
 301
 302 static void __exit ir_core_exit(void)
 303 {
 304         class_unregister(&ir_input_class);
 305 }
 306
 307 module_init(ir_core_init);
 308 module_exit(ir_core_exit);