drivers/reset/amlogic/reset-meson-common.c

// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
/*
 * Amlogic Meson Reset core functions
 *
 * Copyright (c) 2016-2024 BayLibre, SAS.
 * Authors: Neil Armstrong <narmstrong@baylibre.com>
 *          Jerome Brunet <jbrunet@baylibre.com>
 */

#include <linux/device.h>
#include <linux/module.h>
#include <linux/regmap.h>
#include <linux/reset-controller.h>

#include "reset-meson.h"

struct meson_reset {
	const struct meson_reset_param *param;
	struct reset_controller_dev rcdev;
	struct regmap *map;
};

static void meson_reset_offset_and_bit(struct meson_reset *data,
				       unsigned long id,
				       unsigned int *offset,
				       unsigned int *bit)
{
	unsigned int stride = regmap_get_reg_stride(data->map);

	*offset = (id / (stride * BITS_PER_BYTE)) * stride;
	*bit = id % (stride * BITS_PER_BYTE);
}

static int meson_reset_reset(struct reset_controller_dev *rcdev,
			     unsigned long id)
{
	struct meson_reset *data =
		container_of(rcdev, struct meson_reset, rcdev);
	unsigned int offset, bit;

	meson_reset_offset_and_bit(data, id, &offset, &bit);
	offset += data->param->reset_offset;

	return regmap_write(data->map, offset, BIT(bit));
}

static int meson_reset_level(struct reset_controller_dev *rcdev,
			     unsigned long id, bool assert)
{
	struct meson_reset *data =
		container_of(rcdev, struct meson_reset, rcdev);
	unsigned int offset, bit;

	meson_reset_offset_and_bit(data, id, &offset, &bit);
	offset += data->param->level_offset;
	assert ^= data->param->level_low_reset;

	return regmap_update_bits(data->map, offset,
				  BIT(bit), assert ? BIT(bit) : 0);
}

static int meson_reset_status(struct reset_controller_dev *rcdev,
			      unsigned long id)
{
	struct meson_reset *data =
		container_of(rcdev, struct meson_reset, rcdev);
	unsigned int val, offset, bit;

	meson_reset_offset_and_bit(data, id, &offset, &bit);
	offset += data->param->level_offset;

	regmap_read(data->map, offset, &val);
	val = !!(BIT(bit) & val);

	return val ^ data->param->level_low_reset;
}

static int meson_reset_assert(struct reset_controller_dev *rcdev,
			      unsigned long id)
{
	return meson_reset_level(rcdev, id, true);
}

static int meson_reset_deassert(struct reset_controller_dev *rcdev,
				unsigned long id)
{
	return meson_reset_level(rcdev, id, false);
}

static int meson_reset_level_toggle(struct reset_controller_dev *rcdev,
				    unsigned long id)
{
	int ret;

	ret = meson_reset_assert(rcdev, id);
	if (ret)
		return ret;

	return meson_reset_deassert(rcdev, id);
}

const struct reset_control_ops meson_reset_ops = {
	.reset		= meson_reset_reset,
	.assert		= meson_reset_assert,
	.deassert	= meson_reset_deassert,
	.status		= meson_reset_status,
};
EXPORT_SYMBOL_NS_GPL(meson_reset_ops, "MESON_RESET");

const struct reset_control_ops meson_reset_toggle_ops = {
	.reset		= meson_reset_level_toggle,
	.assert		= meson_reset_assert,
	.deassert	= meson_reset_deassert,
	.status		= meson_reset_status,
};
EXPORT_SYMBOL_NS_GPL(meson_reset_toggle_ops, "MESON_RESET");

int meson_reset_controller_register(struct device *dev, struct regmap *map,
				    const struct meson_reset_param *param)
{
	struct meson_reset *data;

	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	data->param = param;
	data->map = map;
	data->rcdev.owner = dev->driver->owner;
	data->rcdev.nr_resets = param->reset_num;
	data->rcdev.ops = data->param->reset_ops;
	data->rcdev.of_node = dev->of_node;

	return devm_reset_controller_register(dev, &data->rcdev);
}
EXPORT_SYMBOL_NS_GPL(meson_reset_controller_register, "MESON_RESET");

MODULE_DESCRIPTION("Amlogic Meson Reset Core function");
MODULE_AUTHOR("Neil Armstrong <narmstrong@baylibre.com>");
MODULE_AUTHOR("Jerome Brunet <jbrunet@baylibre.com>");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_IMPORT_NS("MESON_RESET");