drivers/leds/led-class-flash.c

   1 /*
   2  * LED Flash class interface
   3  *
   4  * Copyright (C) 2015 Samsung Electronics Co., Ltd.
   5  * Author: Jacek Anaszewski <j.anaszewski@samsung.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11
  12 #include <linux/device.h>
  13 #include <linux/init.h>
  14 #include <linux/led-class-flash.h>
  15 #include <linux/leds.h>
  16 #include <linux/module.h>
  17 #include <linux/slab.h>
  18 #include "leds.h"
  19
  20 #define has_flash_op(fled_cdev, op)                             \
  21         (fled_cdev && fled_cdev->ops->op)
  22
  23 #define call_flash_op(fled_cdev, op, args...)           \
  24         ((has_flash_op(fled_cdev, op)) ?                        \
  25                         (fled_cdev->ops->op(fled_cdev, args)) : \
  26                         -EINVAL)
  27
  28 static const char * const led_flash_fault_names[] = {
  29         "led-over-voltage",
  30         "flash-timeout-exceeded",
  31         "controller-over-temperature",
  32         "controller-short-circuit",
  33         "led-power-supply-over-current",
  34         "indicator-led-fault",
  35         "led-under-voltage",
  36         "controller-under-voltage",
  37         "led-over-temperature",
  38 };
  39
  40 static ssize_t flash_brightness_store(struct device *dev,
  41                 struct device_attribute *attr, const char *buf, size_t size)
  42 {
  43         struct led_classdev *led_cdev = dev_get_drvdata(dev);
  44         struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
  45         unsigned long state;
  46         ssize_t ret;
  47
  48         mutex_lock(&led_cdev->led_access);
  49
  50         if (led_sysfs_is_disabled(led_cdev)) {
  51                 ret = -EBUSY;
  52                 goto unlock;
  53         }
  54
  55         ret = kstrtoul(buf, 10, &state);
  56         if (ret)
  57                 goto unlock;
  58
  59         ret = led_set_flash_brightness(fled_cdev, state);
  60         if (ret < 0)
  61                 goto unlock;
  62
  63         ret = size;
  64 unlock:
  65         mutex_unlock(&led_cdev->led_access);
  66         return ret;
  67 }
  68
  69 static ssize_t flash_brightness_show(struct device *dev,
  70                 struct device_attribute *attr, char *buf)
  71 {
  72         struct led_classdev *led_cdev = dev_get_drvdata(dev);
  73         struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
  74
  75         /* no lock needed for this */
  76         led_update_flash_brightness(fled_cdev);
  77
  78         return sprintf(buf, "%u\n", fled_cdev->brightness.val);
  79 }
  80 static DEVICE_ATTR_RW(flash_brightness);
  81
  82 static ssize_t max_flash_brightness_show(struct device *dev,
  83                 struct device_attribute *attr, char *buf)
  84 {
  85         struct led_classdev *led_cdev = dev_get_drvdata(dev);
  86         struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
  87
  88         return sprintf(buf, "%u\n", fled_cdev->brightness.max);
  89 }
  90 static DEVICE_ATTR_RO(max_flash_brightness);
  91
  92 static ssize_t flash_strobe_store(struct device *dev,
  93                 struct device_attribute *attr, const char *buf, size_t size)
  94 {
  95         struct led_classdev *led_cdev = dev_get_drvdata(dev);
  96         struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
  97         unsigned long state;
  98         ssize_t ret = -EINVAL;
  99
 100         mutex_lock(&led_cdev->led_access);
 101
 102         if (led_sysfs_is_disabled(led_cdev)) {
 103                 ret = -EBUSY;
 104                 goto unlock;
 105         }
 106
 107         ret = kstrtoul(buf, 10, &state);
 108         if (ret)
 109                 goto unlock;
 110
 111         if (state > 1) {
 112                 ret = -EINVAL;
 113                 goto unlock;
 114         }
 115
 116         ret = led_set_flash_strobe(fled_cdev, state);
 117         if (ret < 0)
 118                 goto unlock;
 119         ret = size;
 120 unlock:
 121         mutex_unlock(&led_cdev->led_access);
 122         return ret;
 123 }
 124
 125 static ssize_t flash_strobe_show(struct device *dev,
 126                 struct device_attribute *attr, char *buf)
 127 {
 128         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 129         struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
 130         bool state;
 131         int ret;
 132
 133         /* no lock needed for this */
 134         ret = led_get_flash_strobe(fled_cdev, &state);
 135         if (ret < 0)
 136                 return ret;
 137
 138         return sprintf(buf, "%u\n", state);
 139 }
 140 static DEVICE_ATTR_RW(flash_strobe);
 141
 142 static ssize_t flash_timeout_store(struct device *dev,
 143                 struct device_attribute *attr, const char *buf, size_t size)
 144 {
 145         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 146         struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
 147         unsigned long flash_timeout;
 148         ssize_t ret;
 149
 150         mutex_lock(&led_cdev->led_access);
 151
 152         if (led_sysfs_is_disabled(led_cdev)) {
 153                 ret = -EBUSY;
 154                 goto unlock;
 155         }
 156
 157         ret = kstrtoul(buf, 10, &flash_timeout);
 158         if (ret)
 159                 goto unlock;
 160
 161         ret = led_set_flash_timeout(fled_cdev, flash_timeout);
 162         if (ret < 0)
 163                 goto unlock;
 164
 165         ret = size;
 166 unlock:
 167         mutex_unlock(&led_cdev->led_access);
 168         return ret;
 169 }
 170
 171 static ssize_t flash_timeout_show(struct device *dev,
 172                 struct device_attribute *attr, char *buf)
 173 {
 174         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 175         struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
 176
 177         return sprintf(buf, "%u\n", fled_cdev->timeout.val);
 178 }
 179 static DEVICE_ATTR_RW(flash_timeout);
 180
 181 static ssize_t max_flash_timeout_show(struct device *dev,
 182                 struct device_attribute *attr, char *buf)
 183 {
 184         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 185         struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
 186
 187         return sprintf(buf, "%u\n", fled_cdev->timeout.max);
 188 }
 189 static DEVICE_ATTR_RO(max_flash_timeout);
 190
 191 static ssize_t flash_fault_show(struct device *dev,
 192                 struct device_attribute *attr, char *buf)
 193 {
 194         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 195         struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
 196         u32 fault, mask = 0x1;
 197         char *pbuf = buf;
 198         int i, ret, buf_len;
 199
 200         ret = led_get_flash_fault(fled_cdev, &fault);
 201         if (ret < 0)
 202                 return -EINVAL;
 203
 204         *buf = '\0';
 205
 206         for (i = 0; i < LED_NUM_FLASH_FAULTS; ++i) {
 207                 if (fault & mask) {
 208                         buf_len = sprintf(pbuf, "%s ",
 209                                           led_flash_fault_names[i]);
 210                         pbuf += buf_len;
 211                 }
 212                 mask <<= 1;
 213         }
 214
 215         return sprintf(buf, "%s\n", buf);
 216 }
 217 static DEVICE_ATTR_RO(flash_fault);
 218
 219 static struct attribute *led_flash_strobe_attrs[] = {
 220         &dev_attr_flash_strobe.attr,
 221         NULL,
 222 };
 223
 224 static struct attribute *led_flash_timeout_attrs[] = {
 225         &dev_attr_flash_timeout.attr,
 226         &dev_attr_max_flash_timeout.attr,
 227         NULL,
 228 };
 229
 230 static struct attribute *led_flash_brightness_attrs[] = {
 231         &dev_attr_flash_brightness.attr,
 232         &dev_attr_max_flash_brightness.attr,
 233         NULL,
 234 };
 235
 236 static struct attribute *led_flash_fault_attrs[] = {
 237         &dev_attr_flash_fault.attr,
 238         NULL,
 239 };
 240
 241 static const struct attribute_group led_flash_strobe_group = {
 242         .attrs = led_flash_strobe_attrs,
 243 };
 244
 245 static const struct attribute_group led_flash_timeout_group = {
 246         .attrs = led_flash_timeout_attrs,
 247 };
 248
 249 static const struct attribute_group led_flash_brightness_group = {
 250         .attrs = led_flash_brightness_attrs,
 251 };
 252
 253 static const struct attribute_group led_flash_fault_group = {
 254         .attrs = led_flash_fault_attrs,
 255 };
 256
 257 static void led_flash_resume(struct led_classdev *led_cdev)
 258 {
 259         struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
 260
 261         call_flash_op(fled_cdev, flash_brightness_set,
 262                                         fled_cdev->brightness.val);
 263         call_flash_op(fled_cdev, timeout_set, fled_cdev->timeout.val);
 264 }
 265
 266 static void led_flash_init_sysfs_groups(struct led_classdev_flash *fled_cdev)
 267 {
 268         struct led_classdev *led_cdev = &fled_cdev->led_cdev;
 269         const struct led_flash_ops *ops = fled_cdev->ops;
 270         const struct attribute_group **flash_groups = fled_cdev->sysfs_groups;
 271
 272         int num_sysfs_groups = 0;
 273
 274         flash_groups[num_sysfs_groups++] = &led_flash_strobe_group;
 275
 276         if (ops->flash_brightness_set)
 277                 flash_groups[num_sysfs_groups++] = &led_flash_brightness_group;
 278
 279         if (ops->timeout_set)
 280                 flash_groups[num_sysfs_groups++] = &led_flash_timeout_group;
 281
 282         if (ops->fault_get)
 283                 flash_groups[num_sysfs_groups++] = &led_flash_fault_group;
 284
 285         led_cdev->groups = flash_groups;
 286 }
 287
 288 int led_classdev_flash_register(struct device *parent,
 289                                 struct led_classdev_flash *fled_cdev)
 290 {
 291         struct led_classdev *led_cdev;
 292         const struct led_flash_ops *ops;
 293         int ret;
 294
 295         if (!fled_cdev)
 296                 return -EINVAL;
 297
 298         led_cdev = &fled_cdev->led_cdev;
 299
 300         if (led_cdev->flags & LED_DEV_CAP_FLASH) {
 301                 if (!led_cdev->brightness_set_blocking)
 302                         return -EINVAL;
 303
 304                 ops = fled_cdev->ops;
 305                 if (!ops || !ops->strobe_set)
 306                         return -EINVAL;
 307
 308                 led_cdev->flash_resume = led_flash_resume;
 309
 310                 /* Select the sysfs attributes to be created for the device */
 311                 led_flash_init_sysfs_groups(fled_cdev);
 312         }
 313
 314         /* Register led class device */
 315         ret = led_classdev_register(parent, led_cdev);
 316         if (ret < 0)
 317                 return ret;
 318
 319         return 0;
 320 }
 321 EXPORT_SYMBOL_GPL(led_classdev_flash_register);
 322
 323 void led_classdev_flash_unregister(struct led_classdev_flash *fled_cdev)
 324 {
 325         if (!fled_cdev)
 326                 return;
 327
 328         led_classdev_unregister(&fled_cdev->led_cdev);
 329 }
 330 EXPORT_SYMBOL_GPL(led_classdev_flash_unregister);
 331
 332 static void led_clamp_align(struct led_flash_setting *s)
 333 {
 334         u32 v, offset;
 335
 336         v = s->val + s->step / 2;
 337         v = clamp(v, s->min, s->max);
 338         offset = v - s->min;
 339         offset = s->step * (offset / s->step);
 340         s->val = s->min + offset;
 341 }
 342
 343 int led_set_flash_timeout(struct led_classdev_flash *fled_cdev, u32 timeout)
 344 {
 345         struct led_classdev *led_cdev = &fled_cdev->led_cdev;
 346         struct led_flash_setting *s = &fled_cdev->timeout;
 347
 348         s->val = timeout;
 349         led_clamp_align(s);
 350
 351         if (!(led_cdev->flags & LED_SUSPENDED))
 352                 return call_flash_op(fled_cdev, timeout_set, s->val);
 353
 354         return 0;
 355 }
 356 EXPORT_SYMBOL_GPL(led_set_flash_timeout);
 357
 358 int led_get_flash_fault(struct led_classdev_flash *fled_cdev, u32 *fault)
 359 {
 360         return call_flash_op(fled_cdev, fault_get, fault);
 361 }
 362 EXPORT_SYMBOL_GPL(led_get_flash_fault);
 363
 364 int led_set_flash_brightness(struct led_classdev_flash *fled_cdev,
 365                                 u32 brightness)
 366 {
 367         struct led_classdev *led_cdev = &fled_cdev->led_cdev;
 368         struct led_flash_setting *s = &fled_cdev->brightness;
 369
 370         s->val = brightness;
 371         led_clamp_align(s);
 372
 373         if (!(led_cdev->flags & LED_SUSPENDED))
 374                 return call_flash_op(fled_cdev, flash_brightness_set, s->val);
 375
 376         return 0;
 377 }
 378 EXPORT_SYMBOL_GPL(led_set_flash_brightness);
 379
 380 int led_update_flash_brightness(struct led_classdev_flash *fled_cdev)
 381 {
 382         struct led_flash_setting *s = &fled_cdev->brightness;
 383         u32 brightness;
 384
 385         if (has_flash_op(fled_cdev, flash_brightness_get)) {
 386                 int ret = call_flash_op(fled_cdev, flash_brightness_get,
 387                                                 &brightness);
 388                 if (ret < 0)
 389                         return ret;
 390
 391                 s->val = brightness;
 392         }
 393
 394         return 0;
 395 }
 396 EXPORT_SYMBOL_GPL(led_update_flash_brightness);
 397
 398 MODULE_AUTHOR("Jacek Anaszewski <j.anaszewski@samsung.com>");
 399 MODULE_DESCRIPTION("LED Flash class interface");
 400 MODULE_LICENSE("GPL v2");