cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

leds-syscon.c (3313B)

      1// SPDX-License-Identifier: GPL-2.0-or-later
      2/*
      3 * Generic Syscon LEDs Driver
      4 *
      5 * Copyright (c) 2014, Linaro Limited
      6 * Author: Linus Walleij <linus.walleij@linaro.org>
      7 */
      8#include <linux/io.h>
      9#include <linux/init.h>
     10#include <linux/of_device.h>
     11#include <linux/of_address.h>
     12#include <linux/platform_device.h>
     13#include <linux/stat.h>
     14#include <linux/slab.h>
     15#include <linux/mfd/syscon.h>
     16#include <linux/regmap.h>
     17#include <linux/leds.h>
     18
     19/**
     20 * struct syscon_led - state container for syscon based LEDs
     21 * @cdev: LED class device for this LED
     22 * @map: regmap to access the syscon device backing this LED
     23 * @offset: the offset into the syscon regmap for the LED register
     24 * @mask: the bit in the register corresponding to the LED
     25 * @state: current state of the LED
     26 */
     27struct syscon_led {
     28	struct led_classdev cdev;
     29	struct regmap *map;
     30	u32 offset;
     31	u32 mask;
     32	bool state;
     33};
     34
     35static void syscon_led_set(struct led_classdev *led_cdev,
     36	enum led_brightness value)
     37{
     38	struct syscon_led *sled =
     39		container_of(led_cdev, struct syscon_led, cdev);
     40	u32 val;
     41	int ret;
     42
     43	if (value == LED_OFF) {
     44		val = 0;
     45		sled->state = false;
     46	} else {
     47		val = sled->mask;
     48		sled->state = true;
     49	}
     50
     51	ret = regmap_update_bits(sled->map, sled->offset, sled->mask, val);
     52	if (ret < 0)
     53		dev_err(sled->cdev.dev, "error updating LED status\n");
     54}
     55
     56static int syscon_led_probe(struct platform_device *pdev)
     57{
     58	struct led_init_data init_data = {};
     59	struct device *dev = &pdev->dev;
     60	struct device_node *np = dev_of_node(dev);
     61	struct device *parent;
     62	struct regmap *map;
     63	struct syscon_led *sled;
     64	const char *state;
     65	int ret;
     66
     67	parent = dev->parent;
     68	if (!parent) {
     69		dev_err(dev, "no parent for syscon LED\n");
     70		return -ENODEV;
     71	}
     72	map = syscon_node_to_regmap(dev_of_node(parent));
     73	if (IS_ERR(map)) {
     74		dev_err(dev, "no regmap for syscon LED parent\n");
     75		return PTR_ERR(map);
     76	}
     77
     78	sled = devm_kzalloc(dev, sizeof(*sled), GFP_KERNEL);
     79	if (!sled)
     80		return -ENOMEM;
     81
     82	sled->map = map;
     83
     84	if (of_property_read_u32(np, "offset", &sled->offset))
     85		return -EINVAL;
     86	if (of_property_read_u32(np, "mask", &sled->mask))
     87		return -EINVAL;
     88
     89	state = of_get_property(np, "default-state", NULL);
     90	if (state) {
     91		if (!strcmp(state, "keep")) {
     92			u32 val;
     93
     94			ret = regmap_read(map, sled->offset, &val);
     95			if (ret < 0)
     96				return ret;
     97			sled->state = !!(val & sled->mask);
     98		} else if (!strcmp(state, "on")) {
     99			sled->state = true;
    100			ret = regmap_update_bits(map, sled->offset,
    101						 sled->mask,
    102						 sled->mask);
    103			if (ret < 0)
    104				return ret;
    105		} else {
    106			sled->state = false;
    107			ret = regmap_update_bits(map, sled->offset,
    108						 sled->mask, 0);
    109			if (ret < 0)
    110				return ret;
    111		}
    112	}
    113	sled->cdev.brightness_set = syscon_led_set;
    114
    115	init_data.fwnode = of_fwnode_handle(np);
    116
    117	ret = devm_led_classdev_register_ext(dev, &sled->cdev, &init_data);
    118	if (ret < 0)
    119		return ret;
    120
    121	platform_set_drvdata(pdev, sled);
    122	dev_info(dev, "registered LED %s\n", sled->cdev.name);
    123
    124	return 0;
    125}
    126
    127static const struct of_device_id of_syscon_leds_match[] = {
    128	{ .compatible = "register-bit-led", },
    129	{},
    130};
    131
    132static struct platform_driver syscon_led_driver = {
    133	.probe		= syscon_led_probe,
    134	.driver		= {
    135		.name	= "leds-syscon",
    136		.of_match_table = of_syscon_leds_match,
    137		.suppress_bind_attrs = true,
    138	},
    139};
    140builtin_platform_driver(syscon_led_driver);