drivers/leds/leds-ns2.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * leds-ns2.c - Driver for the Network Space v2 (and parents) dual-GPIO LED
0004  *
0005  * Copyright (C) 2010 LaCie
0006  *
0007  * Author: Simon Guinot <sguinot@lacie.com>
0008  *
0009  * Based on leds-gpio.c by Raphael Assenat <raph@8d.com>
0010  */
0011
0012 #include <linux/kernel.h>
0013 #include <linux/platform_device.h>
0014 #include <linux/slab.h>
0015 #include <linux/gpio/consumer.h>
0016 #include <linux/leds.h>
0017 #include <linux/module.h>
0018 #include <linux/of.h>
0019 #include "leds.h"
0020
0021 enum ns2_led_modes {
0022     NS_V2_LED_OFF,
0023     NS_V2_LED_ON,
0024     NS_V2_LED_SATA,
0025 };
0026
0027 /*
0028  * If the size of this structure or types of its members is changed,
0029  * the filling of array modval in function ns2_led_register must be changed
0030  * accordingly.
0031  */
0032 struct ns2_led_modval {
0033     u32         mode;
0034     u32         cmd_level;
0035     u32         slow_level;
0036 } __packed;
0037
0038 /*
0039  * The Network Space v2 dual-GPIO LED is wired to a CPLD. Three different LED
0040  * modes are available: off, on and SATA activity blinking. The LED modes are
0041  * controlled through two GPIOs (command and slow): each combination of values
0042  * for the command/slow GPIOs corresponds to a LED mode.
0043  */
0044
0045 struct ns2_led {
0046     struct led_classdev cdev;
0047     struct gpio_desc    *cmd;
0048     struct gpio_desc    *slow;
0049     bool            can_sleep;
0050     unsigned char       sata; /* True when SATA mode active. */
0051     rwlock_t        rw_lock; /* Lock GPIOs. */
0052     int         num_modes;
0053     struct ns2_led_modval   *modval;
0054 };
0055
0056 static int ns2_led_get_mode(struct ns2_led *led, enum ns2_led_modes *mode)
0057 {
0058     int i;
0059     int cmd_level;
0060     int slow_level;
0061
0062     cmd_level = gpiod_get_value_cansleep(led->cmd);
0063     slow_level = gpiod_get_value_cansleep(led->slow);
0064
0065     for (i = 0; i < led->num_modes; i++) {
0066         if (cmd_level == led->modval[i].cmd_level &&
0067             slow_level == led->modval[i].slow_level) {
0068             *mode = led->modval[i].mode;
0069             return 0;
0070         }
0071     }
0072
0073     return -EINVAL;
0074 }
0075
0076 static void ns2_led_set_mode(struct ns2_led *led, enum ns2_led_modes mode)
0077 {
0078     int i;
0079     unsigned long flags;
0080
0081     for (i = 0; i < led->num_modes; i++)
0082         if (mode == led->modval[i].mode)
0083             break;
0084
0085     if (i == led->num_modes)
0086         return;
0087
0088     write_lock_irqsave(&led->rw_lock, flags);
0089
0090     if (!led->can_sleep) {
0091         gpiod_set_value(led->cmd, led->modval[i].cmd_level);
0092         gpiod_set_value(led->slow, led->modval[i].slow_level);
0093         goto exit_unlock;
0094     }
0095
0096     gpiod_set_value_cansleep(led->cmd, led->modval[i].cmd_level);
0097     gpiod_set_value_cansleep(led->slow, led->modval[i].slow_level);
0098
0099 exit_unlock:
0100     write_unlock_irqrestore(&led->rw_lock, flags);
0101 }
0102
0103 static void ns2_led_set(struct led_classdev *led_cdev,
0104             enum led_brightness value)
0105 {
0106     struct ns2_led *led = container_of(led_cdev, struct ns2_led, cdev);
0107     enum ns2_led_modes mode;
0108
0109     if (value == LED_OFF)
0110         mode = NS_V2_LED_OFF;
0111     else if (led->sata)
0112         mode = NS_V2_LED_SATA;
0113     else
0114         mode = NS_V2_LED_ON;
0115
0116     ns2_led_set_mode(led, mode);
0117 }
0118
0119 static int ns2_led_set_blocking(struct led_classdev *led_cdev,
0120             enum led_brightness value)
0121 {
0122     ns2_led_set(led_cdev, value);
0123     return 0;
0124 }
0125
0126 static ssize_t ns2_led_sata_store(struct device *dev,
0127                   struct device_attribute *attr,
0128                   const char *buff, size_t count)
0129 {
0130     struct led_classdev *led_cdev = dev_get_drvdata(dev);
0131     struct ns2_led *led = container_of(led_cdev, struct ns2_led, cdev);
0132     int ret;
0133     unsigned long enable;
0134
0135     ret = kstrtoul(buff, 10, &enable);
0136     if (ret < 0)
0137         return ret;
0138
0139     enable = !!enable;
0140
0141     if (led->sata == enable)
0142         goto exit;
0143
0144     led->sata = enable;
0145
0146     if (!led_get_brightness(led_cdev))
0147         goto exit;
0148
0149     if (enable)
0150         ns2_led_set_mode(led, NS_V2_LED_SATA);
0151     else
0152         ns2_led_set_mode(led, NS_V2_LED_ON);
0153
0154 exit:
0155     return count;
0156 }
0157
0158 static ssize_t ns2_led_sata_show(struct device *dev,
0159                  struct device_attribute *attr, char *buf)
0160 {
0161     struct led_classdev *led_cdev = dev_get_drvdata(dev);
0162     struct ns2_led *led = container_of(led_cdev, struct ns2_led, cdev);
0163
0164     return sprintf(buf, "%d\n", led->sata);
0165 }
0166
0167 static DEVICE_ATTR(sata, 0644, ns2_led_sata_show, ns2_led_sata_store);
0168
0169 static struct attribute *ns2_led_attrs[] = {
0170     &dev_attr_sata.attr,
0171     NULL
0172 };
0173 ATTRIBUTE_GROUPS(ns2_led);
0174
0175 static int ns2_led_register(struct device *dev, struct fwnode_handle *node,
0176                 struct ns2_led *led)
0177 {
0178     struct led_init_data init_data = {};
0179     struct ns2_led_modval *modval;
0180     enum ns2_led_modes mode;
0181     int nmodes, ret;
0182
0183     led->cmd = devm_fwnode_gpiod_get_index(dev, node, "cmd", 0, GPIOD_ASIS,
0184                            fwnode_get_name(node));
0185     if (IS_ERR(led->cmd))
0186         return PTR_ERR(led->cmd);
0187
0188     led->slow = devm_fwnode_gpiod_get_index(dev, node, "slow", 0,
0189                         GPIOD_ASIS,
0190                         fwnode_get_name(node));
0191     if (IS_ERR(led->slow))
0192         return PTR_ERR(led->slow);
0193
0194     ret = fwnode_property_count_u32(node, "modes-map");
0195     if (ret < 0 || ret % 3) {
0196         dev_err(dev, "Missing or malformed modes-map for %pfw\n", node);
0197         return -EINVAL;
0198     }
0199
0200     nmodes = ret / 3;
0201     modval = devm_kcalloc(dev, nmodes, sizeof(*modval), GFP_KERNEL);
0202     if (!modval)
0203         return -ENOMEM;
0204
0205     fwnode_property_read_u32_array(node, "modes-map", (void *)modval,
0206                        nmodes * 3);
0207
0208     rwlock_init(&led->rw_lock);
0209
0210     led->cdev.blink_set = NULL;
0211     led->cdev.flags |= LED_CORE_SUSPENDRESUME;
0212     led->cdev.groups = ns2_led_groups;
0213     led->can_sleep = gpiod_cansleep(led->cmd) || gpiod_cansleep(led->slow);
0214     if (led->can_sleep)
0215         led->cdev.brightness_set_blocking = ns2_led_set_blocking;
0216     else
0217         led->cdev.brightness_set = ns2_led_set;
0218     led->num_modes = nmodes;
0219     led->modval = modval;
0220
0221     ret = ns2_led_get_mode(led, &mode);
0222     if (ret < 0)
0223         return ret;
0224
0225     /* Set LED initial state. */
0226     led->sata = (mode == NS_V2_LED_SATA) ? 1 : 0;
0227     led->cdev.brightness = (mode == NS_V2_LED_OFF) ? LED_OFF : LED_FULL;
0228
0229     init_data.fwnode = node;
0230
0231     ret = devm_led_classdev_register_ext(dev, &led->cdev, &init_data);
0232     if (ret)
0233         dev_err(dev, "Failed to register LED for node %pfw\n", node);
0234
0235     return ret;
0236 }
0237
0238 static int ns2_led_probe(struct platform_device *pdev)
0239 {
0240     struct device *dev = &pdev->dev;
0241     struct fwnode_handle *child;
0242     struct ns2_led *leds;
0243     int count;
0244     int ret;
0245
0246     count = device_get_child_node_count(dev);
0247     if (!count)
0248         return -ENODEV;
0249
0250     leds = devm_kzalloc(dev, array_size(sizeof(*leds), count), GFP_KERNEL);
0251     if (!leds)
0252         return -ENOMEM;
0253
0254     device_for_each_child_node(dev, child) {
0255         ret = ns2_led_register(dev, child, leds++);
0256         if (ret) {
0257             fwnode_handle_put(child);
0258             return ret;
0259         }
0260     }
0261
0262     return 0;
0263 }
0264
0265 static const struct of_device_id of_ns2_leds_match[] = {
0266     { .compatible = "lacie,ns2-leds", },
0267     {},
0268 };
0269 MODULE_DEVICE_TABLE(of, of_ns2_leds_match);
0270
0271 static struct platform_driver ns2_led_driver = {
0272     .probe      = ns2_led_probe,
0273     .driver     = {
0274         .name       = "leds-ns2",
0275         .of_match_table = of_ns2_leds_match,
0276     },
0277 };
0278
0279 module_platform_driver(ns2_led_driver);
0280
0281 MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>");
0282 MODULE_DESCRIPTION("Network Space v2 LED driver");
0283 MODULE_LICENSE("GPL");
0284 MODULE_ALIAS("platform:leds-ns2");