linux/arch/x86/platform/geode/geode-common.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Shared helpers to register GPIO-connected buttons and LEDs
 * on AMD Geode boards.
 */

#include <linux/err.h>
#include <linux/gpio/machine.h>
#include <linux/gpio/property.h>
#include <linux/input.h>
#include <linux/leds.h>
#include <linux/platform_device.h>
#include <linux/slab.h>

#include "geode-common.h"

static const struct software_node geode_gpiochip_node = {
	.name = "cs5535-gpio",
};

static const struct property_entry geode_gpio_keys_props[] = {
	PROPERTY_ENTRY_U32("poll-interval", 20),
	{ }
};

static const struct software_node geode_gpio_keys_node = {
	.name = "geode-gpio-keys",
	.properties = geode_gpio_keys_props,
};

static struct software_node_ref_args geode_restart_gpio_ref;

static const struct property_entry geode_restart_key_props[] = {
	PROPERTY_ENTRY_REF_ARRAY_LEN("gpios", &geode_restart_gpio_ref, 1),
	PROPERTY_ENTRY_U32("linux,code", KEY_RESTART),
	PROPERTY_ENTRY_STRING("label", "Reset button"),
	PROPERTY_ENTRY_U32("debounce-interval", 100),
	{ }
};

static const struct software_node geode_restart_key_node = {
	.parent = &geode_gpio_keys_node,
	.properties = geode_restart_key_props,
};

static const struct software_node *geode_gpio_keys_swnodes[] __initconst = {
	&geode_gpiochip_node,
	&geode_gpio_keys_node,
	&geode_restart_key_node,
	NULL
};

/*
 * Creates gpio-keys-polled device for the restart key.
 *
 * Note that it needs to be called first, before geode_create_leds(),
 * because it registers gpiochip software node used by both gpio-keys and
 * leds-gpio devices.
 */
int __init geode_create_restart_key(unsigned int pin)
{
	struct platform_device_info keys_info = {
		.name	= "gpio-keys-polled",
		.id	= 1,
	};
	struct platform_device *pd;
	int err;

	geode_restart_gpio_ref = SOFTWARE_NODE_REFERENCE(&geode_gpiochip_node,
							 pin, GPIO_ACTIVE_LOW);

	err = software_node_register_node_group(geode_gpio_keys_swnodes);
	if (err) {
		pr_err("failed to register gpio-keys software nodes: %d\n", err);
		return err;
	}

	keys_info.fwnode = software_node_fwnode(&geode_gpio_keys_node);

	pd = platform_device_register_full(&keys_info);
	err = PTR_ERR_OR_ZERO(pd);
	if (err) {
		pr_err("failed to create gpio-keys device: %d\n", err);
		software_node_unregister_node_group(geode_gpio_keys_swnodes);
		return err;
	}

	return 0;
}

static const struct software_node geode_gpio_leds_node = {
	.name = "geode-leds",
};

#define MAX_LEDS	3

int __init geode_create_leds(const char *label, const struct geode_led *leds,
			      unsigned int n_leds)
{
	const struct software_node *group[MAX_LEDS + 2] = { 0 };
	struct software_node *swnodes;
	struct property_entry *props;
	struct software_node_ref_args *gpio_refs;
	struct platform_device_info led_info = {
		.name	= "leds-gpio",
		.id	= PLATFORM_DEVID_NONE,
	};
	struct platform_device *led_dev;
	const char *node_name;
	int err;
	int i;

	if (n_leds > MAX_LEDS) {
		pr_err("%s: too many LEDs\n", __func__);
		return -EINVAL;
	}

	swnodes = kzalloc_objs(*swnodes, n_leds);
	if (!swnodes)
		return -ENOMEM;

	/*
	 * Each LED is represented by 3 properties: "gpios",
	 * "linux,default-trigger", and am empty terminator.
	 */
	props = kzalloc_objs(*props, n_leds * 3);
	if (!props) {
		err = -ENOMEM;
		goto err_free_swnodes;
	}

	gpio_refs = kzalloc_objs(*gpio_refs, n_leds);
	if (!gpio_refs) {
		err = -ENOMEM;
		goto err_free_props;
	}

	group[0] = &geode_gpio_leds_node;
	for (i = 0; i < n_leds; i++) {
		node_name = kasprintf(GFP_KERNEL, "%s:%d", label, i);
		if (!node_name) {
			err = -ENOMEM;
			goto err_free_names;
		}

		gpio_refs[i] = SOFTWARE_NODE_REFERENCE(&geode_gpiochip_node,
						       leds[i].pin,
						       GPIO_ACTIVE_LOW);
		props[i * 3 + 0] =
			PROPERTY_ENTRY_REF_ARRAY_LEN("gpios", &gpio_refs[i], 1);
		props[i * 3 + 1] =
			PROPERTY_ENTRY_STRING("linux,default-trigger",
					      leds[i].default_on ?
					      "default-on" : "default-off");
		/* props[i * 3 + 2] is an empty terminator */

		swnodes[i] = SOFTWARE_NODE(node_name, &props[i * 3],
					   &geode_gpio_leds_node);
		group[i + 1] = &swnodes[i];
	}

	err = software_node_register_node_group(group);
	if (err) {
		pr_err("failed to register LED software nodes: %d\n", err);
		goto err_free_names;
	}

	led_info.fwnode = software_node_fwnode(&geode_gpio_leds_node);

	led_dev = platform_device_register_full(&led_info);
	err = PTR_ERR_OR_ZERO(led_dev);
	if (err) {
		pr_err("failed to create LED device: %d\n", err);
		goto err_unregister_group;
	}

	return 0;

err_unregister_group:
	software_node_unregister_node_group(group);
err_free_names:
	while (--i >= 0)
		kfree(swnodes[i].name);
	kfree(gpio_refs);
err_free_props:
	kfree(props);
err_free_swnodes:
	kfree(swnodes);
	return err;
}