path: root/drivers/pinctrl/sunxi/pinctrl-sunxi.c

/*
 * (C) Copyright 2017 Theobroma Systems Design und Consulting GmbH
 *
 * In parts based on linux/drivers/pinctrl/pinctrl-sunxi.c, which is
 *   Copyright (C) 2012 Maxime Ripard
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */



#include <common.h>
#include <dm.h>
#include <errno.h>
#include <syscon.h>
#include <asm/io.h>
#include <asm/arch/clock.h>
#include <asm/gpio.h>
#if defined(CONFIG_DM_GPIO) && !defined(CONFIG_DM_ALLOW_MULTIPLE_DRIVERS)
#include <asm/arch/gpio-internal.h>
#endif
#include <dm/device-internal.h>
#include <dm/lists.h>
#include <dm/pinctrl.h>
#include <dt-bindings/pinctrl/sun4i-a10.h>
#include <dt-bindings/gpio/gpio.h>
#include <linux/kernel.h>
#include "pinctrl-sunxi.h"

DECLARE_GLOBAL_DATA_PTR;

struct sunxi_pctrl_priv {
	void *base;
#if defined(CONFIG_DM_GPIO) && !defined(CONFIG_DM_ALLOW_MULTIPLE_DRIVERS)
	struct sunxi_gpio_soc_data gpio_soc_data;
	struct udevice *gpio_dev;
#endif
};

static int sunxi_pctrl_parse_drive_prop(const void *blob, int node)
{
	int val;

	/* Try the new style binding */
	val = fdtdec_get_int(blob, node, "drive-strength", -EINVAL);
	if (val >= 0) {
		/* We can't go below 10mA ... */
		if (val < 10)
			return -EINVAL;

		/* ... and only up to 40 mA ... */
		if (val > 40)
			val = 40;

		/* by steps of 10 mA */
		return rounddown(val, 10);
	}

	/* And then fall back to the old binding */
	val = fdtdec_get_int(blob, node, "allwinner,drive", -EINVAL);
	if (val < 0)
		return -EINVAL;

	return (val + 1) * 10;
}

static int sunxi_pctrl_parse_bias_prop(const void *blob, int node)
{
	/* Try the new style binding */
	if (fdtdec_get_bool(blob, node, "bias-pull-up"))
		return SUN4I_PINCTRL_PULL_UP;

	if (fdtdec_get_bool(blob, node, "bias-pull-down"))
		return SUN4I_PINCTRL_PULL_DOWN;

	if (fdtdec_get_bool(blob, node, "bias-disable"))
		return SUN4I_PINCTRL_NO_PULL;

	/* And fall back to the old binding */
	return fdtdec_get_int(blob, node, "allwinner,pull", -EINVAL);
}

static const struct sunxi_desc_pin *sunxi_pctrl_pin_by_name(struct udevice *dev,
							    const char *name)
{
	const struct sunxi_pinctrl_desc *data =
		(struct sunxi_pinctrl_desc *)dev_get_driver_data(dev);
	int i;

	for (i = 0; i < data->npins; ++i)
		if (!strcmp(data->pins[i].pin.name, name))
			return &data->pins[i];

	return NULL;
}

static int sunxi_pctrl_muxval_by_name(const struct sunxi_desc_pin *pin,
				      const char *name)
{
	const struct sunxi_desc_function *func;

	if (!pin)
		return -EINVAL;

	for (func = pin->functions; func->name; func++)
		if (!strcmp(func->name, name))
			return func->muxval;

	return -ENOENT;
}

static void sunxi_pctrl_set_function(struct udevice *dev,
				     unsigned pin, int function)
{
	struct sunxi_pctrl_priv *priv = dev_get_priv(dev);
	const struct sunxi_pinctrl_desc *data =
		(struct sunxi_pinctrl_desc *)dev_get_driver_data(dev);
	u32 val, mask;

	if (function < 0)
		return;

	pin -= data->pin_base;
	mask = MUX_PINS_MASK << sunxi_mux_offset(pin);
	val = function << sunxi_mux_offset(pin);
	clrsetbits_le32(priv->base + sunxi_mux_reg(pin), mask, val);
}

static void sunxi_pctrl_set_dlevel(struct udevice *dev,
				   unsigned pin, int dlevel)
{
	struct sunxi_pctrl_priv *priv = dev_get_priv(dev);
	const struct sunxi_pinctrl_desc *data =
		(struct sunxi_pinctrl_desc *)dev_get_driver_data(dev);
	u32 val, mask;

	if (dlevel < 0)
		return;

	pin -= data->pin_base;
	mask = DLEVEL_PINS_MASK << sunxi_dlevel_offset(pin);
	val = dlevel << sunxi_dlevel_offset(pin);
	clrsetbits_le32(priv->base + sunxi_dlevel_reg(pin), mask, val);
}

static void sunxi_pctrl_set_bias(struct udevice *dev,
				 unsigned pin, int bias)
{
	struct sunxi_pctrl_priv *priv = dev_get_priv(dev);
	const struct sunxi_pinctrl_desc *data =
		(struct sunxi_pinctrl_desc *)dev_get_driver_data(dev);
	u32 val, mask;

	if (bias < 0)
		return;

	pin -= data->pin_base;
	mask = PULL_PINS_MASK << sunxi_pull_offset(pin);
	val = bias << sunxi_pull_offset(pin);
	clrsetbits_le32(priv->base + sunxi_pull_reg(pin), mask, val);
}

static const char *sunxi_pctrl_find_pins_prop(const char *blob,
					      int node,
					      int *npins)
{
	int count;

	/* Try the generic binding */
	count = fdt_stringlist_count(blob, node, "pins");
	if (count > 0) {
		*npins = count;
		return "pins";
	}

	/* And fall back to our legacy one */
	count = fdt_stringlist_count(blob, node, "allwinner,pins");
	if (count > 0) {
		*npins = count;
		return "allwinner,pins";
	}

	return NULL;
}

static const char* sunxi_pctrl_parse_function(const char *blob, int node)
{
	const char *function = NULL;

	/* Try the generic binding */
	function = fdt_getprop(blob, node, "function", NULL);

	/* And fall back to our legacy one */
	if (!function)
		function = fdt_getprop(blob, node, "allwinner,function", NULL);

	return function;
}

static int sunxi_pctrl_set_state(struct udevice *dev, struct udevice *config)
{
	const void *blob = gd->fdt_blob;
	int node = config->of_offset;
	const char *pin_prop;
	const char *function;
	int drive, bias;
	int i, npins;

	debug("%s: %s %s\n", __func__, dev->name, config->name);

	pin_prop = sunxi_pctrl_find_pins_prop(blob, node, &npins);
	if (!pin_prop) {
		debug("%s: missing pins property in node %s\n",
		      dev->name, config->name);
		return -EINVAL;
	}

	function = sunxi_pctrl_parse_function(blob, node);
	if (!function) {
		debug("%s: missing allwinner,function property in node %s\n",
		      dev->name, config->name);
		return -EINVAL;
	}

	drive = sunxi_pctrl_parse_drive_prop(blob, node);
	bias = sunxi_pctrl_parse_bias_prop(blob, node);

	debug("%s: function %s, drive %d, bias %d\n",
	      config->name, function, drive, bias);

	for (i = 0; i < npins; ++i) {
		const struct sunxi_desc_pin *pin;
		const char *pin_name =
			fdt_stringlist_get(blob, node, pin_prop, i, NULL);
		int muxval;

		if (!pin_name)
			continue;

		pin = sunxi_pctrl_pin_by_name(dev, pin_name);
		if (!pin) {
			debug("%s: unknown pin %s\n", dev->name, pin_name);
			continue;
		}

		muxval = sunxi_pctrl_muxval_by_name(pin, function);

		sunxi_pctrl_set_function(dev, pin->pin.number, muxval);
		sunxi_pctrl_set_dlevel(dev, pin->pin.number, drive);
		sunxi_pctrl_set_bias(dev, pin->pin.number, bias);
	}

	return 0;
}

#if defined(CONFIG_DM_GPIO) && !defined(CONFIG_DM_ALLOW_MULTIPLE_DRIVERS)
static inline void soc_data_from_desc(const struct sunxi_pinctrl_desc *data,
				      struct sunxi_gpio_soc_data *soc_data)
{
	int i;
	unsigned pinnum;
	unsigned low = data->pin_base / PINS_PER_BANK;
	unsigned high = data->pin_base;

	for (i = 0; i < data->npins; ++i) {
		pinnum = data->pins[i].pin.number;
		high = max(high, pinnum);
	}

	/* convert pin-numbers to bank numbers */
	high /= PINS_PER_BANK;

	soc_data->start = low;
	soc_data->no_banks = high - low + 1;
}
#endif

static int sunxi_pctrl_bind_gpio(struct udevice *dev)
{
#if defined(CONFIG_DM_GPIO) && !defined(CONFIG_DM_ALLOW_MULTIPLE_DRIVERS)
	struct sunxi_pctrl_priv *priv = dev_get_priv(dev);
	const struct sunxi_pinctrl_desc *data =
		(struct sunxi_pinctrl_desc *)dev_get_driver_data(dev);
	struct driver *gpio_driver;
	char name[20];
	int ret;

	/* Fill the soc_data for the gpio driver from the pinctrl_desc */
	soc_data_from_desc(data, &priv->gpio_soc_data);

	gpio_driver = lists_driver_lookup_name("gpio_sunxi");
	if (!gpio_driver)
		return -ENOENT;

	ret = device_bind_with_driver_data(dev, gpio_driver, "sunxi_gpio",
					   (ulong)&priv->gpio_soc_data,
					   dev->of_offset, &priv->gpio_dev);

	if (ret < 0)
		return ret;

	snprintf(name, sizeof(name), "sunxi_gpio@%x", (uint32_t)priv->base);
	device_set_name(priv->gpio_dev, name);
#endif

	return 0;
}

static int sunxi_pctrl_probe(struct udevice *dev)
{
	struct sunxi_pctrl_priv *priv = dev_get_priv(dev);
	fdt_addr_t addr_base;
	fdt_size_t size;

	addr_base = fdtdec_get_addr_size_auto_noparent(gd->fdt_blob,
						       dev->of_offset,
						       "reg", 0, &size,
						       false);
	if (addr_base == FDT_ADDR_T_NONE)
		return -EINVAL;

	priv->base = (void *)addr_base;

	return sunxi_pctrl_bind_gpio(dev);
}

static struct pinctrl_ops sunxi_pctrl_ops = {
	.set_state	  = sunxi_pctrl_set_state,
};

#if defined(CONFIG_MACH_SUN50I)
extern const struct sunxi_pinctrl_desc a64_pinctrl_data;
extern const struct sunxi_pinctrl_desc a64_r_pinctrl_data;
#endif

static const struct udevice_id sunxi_pctrl_ids[] = {
#if defined(CONFIG_MACH_SUN50I)
	{ .compatible = "allwinner,sun50i-a64-pinctrl",
	  .data = (ulong)&a64_pinctrl_data },
	{ .compatible = "allwinner,sun50i-a64-r-pinctrl",
	  .data = (ulong)&a64_r_pinctrl_data },
#endif
	{ }
};

U_BOOT_DRIVER(pinctrl_sunxi) = {
	.name		= "sunxi_pctrl",
	.id		= UCLASS_PINCTRL,
	.of_match	= sunxi_pctrl_ids,
	.priv_auto_alloc_size = sizeof(struct sunxi_pctrl_priv),
	.ops		= &sunxi_pctrl_ops,
	.bind		= dm_scan_fdt_dev,
	.probe		= sunxi_pctrl_probe,
};