drivers/leds/leds-syscon.c

   1 /*
   2  * Generic Syscon LEDs Driver
   3  *
   4  * Copyright (c) 2014, Linaro Limited
   5  * Author: Linus Walleij <linus.walleij@linaro.org>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 2 of
  10  * the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  20  * MA 02111-1307 USA
  21  */
  22 #include <linux/io.h>
  23 #include <linux/of_device.h>
  24 #include <linux/of_address.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/stat.h>
  27 #include <linux/slab.h>
  28 #include <linux/mfd/syscon.h>
  29 #include <linux/regmap.h>
  30 #include <linux/leds.h>
  31
  32 /**
  33  * struct syscon_led - state container for syscon based LEDs
  34  * @cdev: LED class device for this LED
  35  * @map: regmap to access the syscon device backing this LED
  36  * @offset: the offset into the syscon regmap for the LED register
  37  * @mask: the bit in the register corresponding to the LED
  38  * @state: current state of the LED
  39  */
  40 struct syscon_led {
  41         struct led_classdev cdev;
  42         struct regmap *map;
  43         u32 offset;
  44         u32 mask;
  45         bool state;
  46 };
  47
  48 static void syscon_led_set(struct led_classdev *led_cdev,
  49         enum led_brightness value)
  50 {
  51         struct syscon_led *sled =
  52                 container_of(led_cdev, struct syscon_led, cdev);
  53         u32 val;
  54         int ret;
  55
  56         if (value == LED_OFF) {
  57                 val = 0;
  58                 sled->state = false;
  59         } else {
  60                 val = sled->mask;
  61                 sled->state = true;
  62         }
  63
  64         ret = regmap_update_bits(sled->map, sled->offset, sled->mask, val);
  65         if (ret < 0)
  66                 dev_err(sled->cdev.dev, "error updating LED status\n");
  67 }
  68
  69 static int __init syscon_leds_spawn(struct device_node *np,
  70                                     struct device *dev,
  71                                     struct regmap *map)
  72 {
  73         struct device_node *child;
  74         int ret;
  75
  76         for_each_available_child_of_node(np, child) {
  77                 struct syscon_led *sled;
  78                 const char *state;
  79
  80                 /* Only check for register-bit-leds */
  81                 if (of_property_match_string(child, "compatible",
  82                                              "register-bit-led") < 0)
  83                         continue;
  84
  85                 sled = devm_kzalloc(dev, sizeof(*sled), GFP_KERNEL);
  86                 if (!sled)
  87                         return -ENOMEM;
  88
  89                 sled->map = map;
  90
  91                 if (of_property_read_u32(child, "offset", &sled->offset))
  92                         return -EINVAL;
  93                 if (of_property_read_u32(child, "mask", &sled->mask))
  94                         return -EINVAL;
  95                 sled->cdev.name =
  96                         of_get_property(child, "label", NULL) ? : child->name;
  97                 sled->cdev.default_trigger =
  98                         of_get_property(child, "linux,default-trigger", NULL);
  99
 100                 state = of_get_property(child, "default-state", NULL);
 101                 if (state) {
 102                         if (!strcmp(state, "keep")) {
 103                                 u32 val;
 104
 105                                 ret = regmap_read(map, sled->offset, &val);
 106                                 if (ret < 0)
 107                                         return ret;
 108                                 sled->state = !!(val & sled->mask);
 109                         } else if (!strcmp(state, "on")) {
 110                                 sled->state = true;
 111                                 ret = regmap_update_bits(map, sled->offset,
 112                                                          sled->mask,
 113                                                          sled->mask);
 114                                 if (ret < 0)
 115                                         return ret;
 116                         } else {
 117                                 sled->state = false;
 118                                 ret = regmap_update_bits(map, sled->offset,
 119                                                          sled->mask, 0);
 120                                 if (ret < 0)
 121                                         return ret;
 122                         }
 123                 }
 124                 sled->cdev.brightness_set = syscon_led_set;
 125
 126                 ret = led_classdev_register(dev, &sled->cdev);
 127                 if (ret < 0)
 128                         return ret;
 129
 130                 dev_info(dev, "registered LED %s\n", sled->cdev.name);
 131         }
 132         return 0;
 133 }
 134
 135 static int __init syscon_leds_init(void)
 136 {
 137         struct device_node *np;
 138
 139         for_each_of_allnodes(np) {
 140                 struct platform_device *pdev;
 141                 struct regmap *map;
 142                 int ret;
 143
 144                 if (!of_device_is_compatible(np, "syscon"))
 145                         continue;
 146
 147                 map = syscon_node_to_regmap(np);
 148                 if (IS_ERR(map)) {
 149                         pr_err("error getting regmap for syscon LEDs\n");
 150                         continue;
 151                 }
 152
 153                 /*
 154                  * If the map is there, the device should be there, we allocate
 155                  * memory on the syscon device's behalf here.
 156                  */
 157                 pdev = of_find_device_by_node(np);
 158                 if (!pdev)
 159                         return -ENODEV;
 160                 ret = syscon_leds_spawn(np, &pdev->dev, map);
 161                 if (ret)
 162                         dev_err(&pdev->dev, "could not spawn syscon LEDs\n");
 163         }
 164
 165         return 0;
 166 }
 167 device_initcall(syscon_leds_init);