1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * leds-ns2.c - Driver for the Network Space v2 (and parents) dual-GPIO LED 4 * 5 * Copyright (C) 2010 LaCie 6 * 7 * Author: Simon Guinot <sguinot@lacie.com> 8 * 9 * Based on leds-gpio.c by Raphael Assenat <raph@8d.com> 10 */ 11 12 #include <linux/kernel.h> 13 #include <linux/platform_device.h> 14 #include <linux/slab.h> 15 #include <linux/gpio/consumer.h> 16 #include <linux/leds.h> 17 #include <linux/module.h> 18 #include <linux/of.h> 19 #include "leds.h" 20 21 enum ns2_led_modes { 22 NS_V2_LED_OFF, 23 NS_V2_LED_ON, 24 NS_V2_LED_SATA, 25 }; 26 27 /* 28 * If the size of this structure or types of its members is changed, 29 * the filling of array modval in function ns2_led_register must be changed 30 * accordingly. 31 */ 32 struct ns2_led_modval { 33 u32 mode; 34 u32 cmd_level; 35 u32 slow_level; 36 } __packed; 37 38 /* 39 * The Network Space v2 dual-GPIO LED is wired to a CPLD. Three different LED 40 * modes are available: off, on and SATA activity blinking. The LED modes are 41 * controlled through two GPIOs (command and slow): each combination of values 42 * for the command/slow GPIOs corresponds to a LED mode. 43 */ 44 45 struct ns2_led { 46 struct led_classdev cdev; 47 struct gpio_desc *cmd; 48 struct gpio_desc *slow; 49 bool can_sleep; 50 unsigned char sata; /* True when SATA mode active. */ 51 rwlock_t rw_lock; /* Lock GPIOs. */ 52 int num_modes; 53 struct ns2_led_modval *modval; 54 }; 55 56 static int ns2_led_get_mode(struct ns2_led *led, enum ns2_led_modes *mode) 57 { 58 int i; 59 int cmd_level; 60 int slow_level; 61 62 cmd_level = gpiod_get_value_cansleep(led->cmd); 63 slow_level = gpiod_get_value_cansleep(led->slow); 64 65 for (i = 0; i < led->num_modes; i++) { 66 if (cmd_level == led->modval[i].cmd_level && 67 slow_level == led->modval[i].slow_level) { 68 *mode = led->modval[i].mode; 69 return 0; 70 } 71 } 72 73 return -EINVAL; 74 } 75 76 static void ns2_led_set_mode(struct ns2_led *led, enum ns2_led_modes mode) 77 { 78 int i; 79 unsigned long flags; 80 81 for (i = 0; i < led->num_modes; i++) 82 if (mode == led->modval[i].mode) 83 break; 84 85 if (i == led->num_modes) 86 return; 87 88 write_lock_irqsave(&led->rw_lock, flags); 89 90 if (!led->can_sleep) { 91 gpiod_set_value(led->cmd, led->modval[i].cmd_level); 92 gpiod_set_value(led->slow, led->modval[i].slow_level); 93 goto exit_unlock; 94 } 95 96 gpiod_set_value_cansleep(led->cmd, led->modval[i].cmd_level); 97 gpiod_set_value_cansleep(led->slow, led->modval[i].slow_level); 98 99 exit_unlock: 100 write_unlock_irqrestore(&led->rw_lock, flags); 101 } 102 103 static void ns2_led_set(struct led_classdev *led_cdev, 104 enum led_brightness value) 105 { 106 struct ns2_led *led = container_of(led_cdev, struct ns2_led, cdev); 107 enum ns2_led_modes mode; 108 109 if (value == LED_OFF) 110 mode = NS_V2_LED_OFF; 111 else if (led->sata) 112 mode = NS_V2_LED_SATA; 113 else 114 mode = NS_V2_LED_ON; 115 116 ns2_led_set_mode(led, mode); 117 } 118 119 static int ns2_led_set_blocking(struct led_classdev *led_cdev, 120 enum led_brightness value) 121 { 122 ns2_led_set(led_cdev, value); 123 return 0; 124 } 125 126 static ssize_t ns2_led_sata_store(struct device *dev, 127 struct device_attribute *attr, 128 const char *buff, size_t count) 129 { 130 struct led_classdev *led_cdev = dev_get_drvdata(dev); 131 struct ns2_led *led = container_of(led_cdev, struct ns2_led, cdev); 132 int ret; 133 unsigned long enable; 134 135 ret = kstrtoul(buff, 10, &enable); 136 if (ret < 0) 137 return ret; 138 139 enable = !!enable; 140 141 if (led->sata == enable) 142 goto exit; 143 144 led->sata = enable; 145 146 if (!led_get_brightness(led_cdev)) 147 goto exit; 148 149 if (enable) 150 ns2_led_set_mode(led, NS_V2_LED_SATA); 151 else 152 ns2_led_set_mode(led, NS_V2_LED_ON); 153 154 exit: 155 return count; 156 } 157 158 static ssize_t ns2_led_sata_show(struct device *dev, 159 struct device_attribute *attr, char *buf) 160 { 161 struct led_classdev *led_cdev = dev_get_drvdata(dev); 162 struct ns2_led *led = container_of(led_cdev, struct ns2_led, cdev); 163 164 return sprintf(buf, "%d\n", led->sata); 165 } 166 167 static DEVICE_ATTR(sata, 0644, ns2_led_sata_show, ns2_led_sata_store); 168 169 static struct attribute *ns2_led_attrs[] = { 170 &dev_attr_sata.attr, 171 NULL 172 }; 173 ATTRIBUTE_GROUPS(ns2_led); 174 175 static int ns2_led_register(struct device *dev, struct fwnode_handle *node, 176 struct ns2_led *led) 177 { 178 struct led_init_data init_data = {}; 179 struct ns2_led_modval *modval; 180 enum ns2_led_modes mode; 181 int nmodes, ret; 182 183 led->cmd = devm_fwnode_gpiod_get_index(dev, node, "cmd", 0, GPIOD_ASIS, 184 fwnode_get_name(node)); 185 if (IS_ERR(led->cmd)) 186 return PTR_ERR(led->cmd); 187 188 led->slow = devm_fwnode_gpiod_get_index(dev, node, "slow", 0, 189 GPIOD_ASIS, 190 fwnode_get_name(node)); 191 if (IS_ERR(led->slow)) 192 return PTR_ERR(led->slow); 193 194 ret = fwnode_property_count_u32(node, "modes-map"); 195 if (ret < 0 || ret % 3) { 196 dev_err(dev, "Missing or malformed modes-map for %pfw\n", node); 197 return -EINVAL; 198 } 199 200 nmodes = ret / 3; 201 modval = devm_kcalloc(dev, nmodes, sizeof(*modval), GFP_KERNEL); 202 if (!modval) 203 return -ENOMEM; 204 205 fwnode_property_read_u32_array(node, "modes-map", (void *)modval, 206 nmodes * 3); 207 208 rwlock_init(&led->rw_lock); 209 210 led->cdev.blink_set = NULL; 211 led->cdev.flags |= LED_CORE_SUSPENDRESUME; 212 led->cdev.groups = ns2_led_groups; 213 led->can_sleep = gpiod_cansleep(led->cmd) || gpiod_cansleep(led->slow); 214 if (led->can_sleep) 215 led->cdev.brightness_set_blocking = ns2_led_set_blocking; 216 else 217 led->cdev.brightness_set = ns2_led_set; 218 led->num_modes = nmodes; 219 led->modval = modval; 220 221 ret = ns2_led_get_mode(led, &mode); 222 if (ret < 0) 223 return ret; 224 225 /* Set LED initial state. */ 226 led->sata = (mode == NS_V2_LED_SATA) ? 1 : 0; 227 led->cdev.brightness = (mode == NS_V2_LED_OFF) ? LED_OFF : LED_FULL; 228 229 init_data.fwnode = node; 230 231 ret = devm_led_classdev_register_ext(dev, &led->cdev, &init_data); 232 if (ret) 233 dev_err(dev, "Failed to register LED for node %pfw\n", node); 234 235 return ret; 236 } 237 238 static int ns2_led_probe(struct platform_device *pdev) 239 { 240 struct device *dev = &pdev->dev; 241 struct ns2_led *leds; 242 int count; 243 int ret; 244 245 count = device_get_child_node_count(dev); 246 if (!count) 247 return -ENODEV; 248 249 leds = devm_kcalloc(dev, count, sizeof(*leds), GFP_KERNEL); 250 if (!leds) 251 return -ENOMEM; 252 253 device_for_each_child_node_scoped(dev, child) { 254 ret = ns2_led_register(dev, child, leds++); 255 if (ret) 256 return ret; 257 } 258 259 return 0; 260 } 261 262 static const struct of_device_id of_ns2_leds_match[] = { 263 { .compatible = "lacie,ns2-leds", }, 264 {}, 265 }; 266 MODULE_DEVICE_TABLE(of, of_ns2_leds_match); 267 268 static struct platform_driver ns2_led_driver = { 269 .probe = ns2_led_probe, 270 .driver = { 271 .name = "leds-ns2", 272 .of_match_table = of_ns2_leds_match, 273 }, 274 }; 275 276 module_platform_driver(ns2_led_driver); 277 278 MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>"); 279 MODULE_DESCRIPTION("Network Space v2 LED driver"); 280 MODULE_LICENSE("GPL"); 281 MODULE_ALIAS("platform:leds-ns2"); 282