target/linux/generic/files/drivers/leds/ledtrig-usbdev.c

   1 /*
   2  * LED USB device Trigger
   3  *
   4  * Toggles the LED to reflect the presence and activity of an USB device
   5  * Copyright (C) Gabor Juhos <juhosg@openwrt.org>
   6  *
   7  * derived from ledtrig-netdev.c:
   8  *      Copyright 2007 Oliver Jowett <oliver@opencloud.com>
   9  *
  10  * ledtrig-netdev.c derived from ledtrig-timer.c:
  11  *      Copyright 2005-2006 Openedhand Ltd.
  12  *      Author: Richard Purdie <rpurdie@openedhand.com>
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License version 2 as
  16  * published by the Free Software Foundation.
  17  *
  18  */
  19
  20 #include <linux/module.h>
  21 #include <linux/jiffies.h>
  22 #include <linux/kernel.h>
  23 #include <linux/init.h>
  24 #include <linux/list.h>
  25 #include <linux/spinlock.h>
  26 #include <linux/device.h>
  27 #include <linux/sysdev.h>
  28 #include <linux/timer.h>
  29 #include <linux/ctype.h>
  30 #include <linux/slab.h>
  31 #include <linux/leds.h>
  32 #include <linux/usb.h>
  33
  34 #include "leds.h"
  35
  36 #define DEV_BUS_ID_SIZE         32
  37
  38 /*
  39  * Configurable sysfs attributes:
  40  *
  41  * device_name - name of the USB device to monitor
  42  * activity_interval - duration of LED blink, in milliseconds
  43  */
  44
  45 struct usbdev_trig_data {
  46         rwlock_t lock;
  47
  48         struct timer_list timer;
  49         struct notifier_block notifier;
  50
  51         struct led_classdev *led_cdev;
  52         struct usb_device *usb_dev;
  53
  54         char device_name[DEV_BUS_ID_SIZE];
  55         unsigned interval;
  56         int last_urbnum;
  57 };
  58
  59 static void usbdev_trig_update_state(struct usbdev_trig_data *td)
  60 {
  61         if (td->usb_dev)
  62                 led_set_brightness(td->led_cdev, LED_FULL);
  63         else
  64                 led_set_brightness(td->led_cdev, LED_OFF);
  65
  66         if (td->interval && td->usb_dev)
  67                 mod_timer(&td->timer, jiffies + td->interval);
  68         else
  69                 del_timer(&td->timer);
  70 }
  71
  72 static ssize_t usbdev_trig_name_show(struct device *dev,
  73                                      struct device_attribute *attr,
  74                                      char *buf)
  75 {
  76         struct led_classdev *led_cdev = dev_get_drvdata(dev);
  77         struct usbdev_trig_data *td = led_cdev->trigger_data;
  78
  79         read_lock(&td->lock);
  80         sprintf(buf, "%s\n", td->device_name);
  81         read_unlock(&td->lock);
  82
  83         return strlen(buf) + 1;
  84 }
  85
  86 struct usbdev_trig_match {
  87         char *device_name;
  88         struct usb_device *usb_dev;
  89 };
  90
  91 static int usbdev_trig_find_usb_dev(struct usb_device *usb_dev, void *data)
  92 {
  93         struct usbdev_trig_match *match = data;
  94
  95         if (strcmp(dev_name(&usb_dev->dev), match->device_name) != 0)
  96                 return 0;
  97
  98         if (WARN_ON(match->usb_dev))
  99                 return 0;
 100
 101         dev_dbg(&usb_dev->dev, "matched this device!\n");
 102         match->usb_dev = usb_get_dev(usb_dev);
 103
 104         return 0;
 105 }
 106
 107 static ssize_t usbdev_trig_name_store(struct device *dev,
 108                                       struct device_attribute *attr,
 109                                       const char *buf,
 110                                       size_t size)
 111 {
 112         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 113         struct usbdev_trig_data *td = led_cdev->trigger_data;
 114
 115         if (size < 0 || size >= DEV_BUS_ID_SIZE)
 116                 return -EINVAL;
 117
 118         write_lock(&td->lock);
 119
 120         strcpy(td->device_name, buf);
 121         if (size > 0 && td->device_name[size - 1] == '\n')
 122                 td->device_name[size - 1] = 0;
 123
 124         if (td->device_name[0] != 0) {
 125                 struct usbdev_trig_match match = {
 126                         .device_name = td->device_name,
 127                 };
 128
 129                 /* check for existing device to update from */
 130                 usb_for_each_dev(&match, usbdev_trig_find_usb_dev);
 131                 if (match.usb_dev) {
 132                         if (td->usb_dev)
 133                                 usb_put_dev(td->usb_dev);
 134
 135                         td->usb_dev = match.usb_dev;
 136                         td->last_urbnum = atomic_read(&match.usb_dev->urbnum);
 137                 }
 138
 139                 /* updates LEDs, may start timers */
 140                 usbdev_trig_update_state(td);
 141         }
 142
 143         write_unlock(&td->lock);
 144         return size;
 145 }
 146
 147 static DEVICE_ATTR(device_name, 0644, usbdev_trig_name_show,
 148                    usbdev_trig_name_store);
 149
 150 static ssize_t usbdev_trig_interval_show(struct device *dev,
 151                                          struct device_attribute *attr,
 152                                          char *buf)
 153 {
 154         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 155         struct usbdev_trig_data *td = led_cdev->trigger_data;
 156
 157         read_lock(&td->lock);
 158         sprintf(buf, "%u\n", jiffies_to_msecs(td->interval));
 159         read_unlock(&td->lock);
 160
 161         return strlen(buf) + 1;
 162 }
 163
 164 static ssize_t usbdev_trig_interval_store(struct device *dev,
 165                                           struct device_attribute *attr,
 166                                           const char *buf,
 167                                           size_t size)
 168 {
 169         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 170         struct usbdev_trig_data *td = led_cdev->trigger_data;
 171         int ret = -EINVAL;
 172         char *after;
 173         unsigned long value = simple_strtoul(buf, &after, 10);
 174         size_t count = after - buf;
 175
 176         if (*after && isspace(*after))
 177                 count++;
 178
 179         if (count == size && value <= 10000) {
 180                 write_lock(&td->lock);
 181                 td->interval = msecs_to_jiffies(value);
 182                 usbdev_trig_update_state(td); /* resets timer */
 183                 write_unlock(&td->lock);
 184                 ret = count;
 185         }
 186
 187         return ret;
 188 }
 189
 190 static DEVICE_ATTR(activity_interval, 0644, usbdev_trig_interval_show,
 191                    usbdev_trig_interval_store);
 192
 193 static int usbdev_trig_notify(struct notifier_block *nb,
 194                               unsigned long evt,
 195                               void *data)
 196 {
 197         struct usb_device *usb_dev;
 198         struct usbdev_trig_data *td;
 199
 200         if (evt != USB_DEVICE_ADD && evt != USB_DEVICE_REMOVE)
 201                 return NOTIFY_DONE;
 202
 203         usb_dev = data;
 204         td = container_of(nb, struct usbdev_trig_data, notifier);
 205
 206         write_lock(&td->lock);
 207
 208         if (strcmp(dev_name(&usb_dev->dev), td->device_name))
 209                 goto done;
 210
 211         if (evt == USB_DEVICE_ADD) {
 212                 usb_get_dev(usb_dev);
 213                 if (td->usb_dev != NULL)
 214                         usb_put_dev(td->usb_dev);
 215                 td->usb_dev = usb_dev;
 216                 td->last_urbnum = atomic_read(&usb_dev->urbnum);
 217         } else if (evt == USB_DEVICE_REMOVE) {
 218                 if (td->usb_dev != NULL) {
 219                         usb_put_dev(td->usb_dev);
 220                         td->usb_dev = NULL;
 221                 }
 222         }
 223
 224         usbdev_trig_update_state(td);
 225
 226 done:
 227         write_unlock(&td->lock);
 228         return NOTIFY_DONE;
 229 }
 230
 231 /* here's the real work! */
 232 static void usbdev_trig_timer(unsigned long arg)
 233 {
 234         struct usbdev_trig_data *td = (struct usbdev_trig_data *)arg;
 235         int new_urbnum;
 236
 237         write_lock(&td->lock);
 238
 239         if (!td->usb_dev || td->interval == 0) {
 240                 /*
 241                  * we don't need to do timer work, just reflect device presence
 242                  */
 243                 if (td->usb_dev)
 244                         led_set_brightness(td->led_cdev, LED_FULL);
 245                 else
 246                         led_set_brightness(td->led_cdev, LED_OFF);
 247
 248                 goto no_restart;
 249         }
 250
 251         if (td->interval)
 252                 new_urbnum = atomic_read(&td->usb_dev->urbnum);
 253         else
 254                 new_urbnum = 0;
 255
 256         if (td->usb_dev) {
 257                 /*
 258                  * Base state is ON (device is present). If there's no device,
 259                  * we don't get this far and the LED is off.
 260                  * OFF -> ON always
 261                  * ON -> OFF on activity
 262                  */
 263                 if (td->led_cdev->brightness == LED_OFF)
 264                         led_set_brightness(td->led_cdev, LED_FULL);
 265                 else if (td->last_urbnum != new_urbnum)
 266                         led_set_brightness(td->led_cdev, LED_OFF);
 267         } else {
 268                 /*
 269                  * base state is OFF
 270                  * ON -> OFF always
 271                  * OFF -> ON on activity
 272                  */
 273                 if (td->led_cdev->brightness == LED_FULL)
 274                         led_set_brightness(td->led_cdev, LED_OFF);
 275                 else if (td->last_urbnum != new_urbnum)
 276                         led_set_brightness(td->led_cdev, LED_FULL);
 277         }
 278
 279         td->last_urbnum = new_urbnum;
 280         mod_timer(&td->timer, jiffies + td->interval);
 281
 282 no_restart:
 283         write_unlock(&td->lock);
 284 }
 285
 286 static void usbdev_trig_activate(struct led_classdev *led_cdev)
 287 {
 288         struct usbdev_trig_data *td;
 289         int rc;
 290
 291         td = kzalloc(sizeof(struct usbdev_trig_data), GFP_KERNEL);
 292         if (!td)
 293                 return;
 294
 295         rwlock_init(&td->lock);
 296
 297         td->notifier.notifier_call = usbdev_trig_notify;
 298         td->notifier.priority = 10;
 299
 300         setup_timer(&td->timer, usbdev_trig_timer, (unsigned long) td);
 301
 302         td->led_cdev = led_cdev;
 303         td->interval = msecs_to_jiffies(50);
 304
 305         led_cdev->trigger_data = td;
 306
 307         rc = device_create_file(led_cdev->dev, &dev_attr_device_name);
 308         if (rc)
 309                 goto err_out;
 310
 311         rc = device_create_file(led_cdev->dev, &dev_attr_activity_interval);
 312         if (rc)
 313                 goto err_out_device_name;
 314
 315         usb_register_notify(&td->notifier);
 316         return;
 317
 318 err_out_device_name:
 319         device_remove_file(led_cdev->dev, &dev_attr_device_name);
 320 err_out:
 321         led_cdev->trigger_data = NULL;
 322         kfree(td);
 323 }
 324
 325 static void usbdev_trig_deactivate(struct led_classdev *led_cdev)
 326 {
 327         struct usbdev_trig_data *td = led_cdev->trigger_data;
 328
 329         if (td) {
 330                 usb_unregister_notify(&td->notifier);
 331
 332                 device_remove_file(led_cdev->dev, &dev_attr_device_name);
 333                 device_remove_file(led_cdev->dev, &dev_attr_activity_interval);
 334
 335                 write_lock(&td->lock);
 336
 337                 if (td->usb_dev) {
 338                         usb_put_dev(td->usb_dev);
 339                         td->usb_dev = NULL;
 340                 }
 341
 342                 write_unlock(&td->lock);
 343
 344                 del_timer_sync(&td->timer);
 345
 346                 kfree(td);
 347         }
 348 }
 349
 350 static struct led_trigger usbdev_led_trigger = {
 351         .name           = "usbdev",
 352         .activate       = usbdev_trig_activate,
 353         .deactivate     = usbdev_trig_deactivate,
 354 };
 355
 356 static int __init usbdev_trig_init(void)
 357 {
 358         return led_trigger_register(&usbdev_led_trigger);
 359 }
 360
 361 static void __exit usbdev_trig_exit(void)
 362 {
 363         led_trigger_unregister(&usbdev_led_trigger);
 364 }
 365
 366 module_init(usbdev_trig_init);
 367 module_exit(usbdev_trig_exit);
 368
 369 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
 370 MODULE_DESCRIPTION("USB device LED trigger");
 371 MODULE_LICENSE("GPL v2");