KernelNanopiR5S/drivers/media/i2c/maxim4c/maxim4c_remote.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Maxim Quad GMSL Deserializer Remode Device Manage
 *
 * Copyright (C) 2023 Rockchip Electronics Co., Ltd.
 *
 * Author: Cai Wenzhong <cwz@rock-chips.com>
 *
 */
#include <linux/module.h>
#include <linux/of_graph.h>
#include <linux/mfd/core.h>
#include "maxim4c_api.h"

static const char *maxim4c_remote_devs_name[MAXIM4C_LINK_ID_MAX] = {
	"remote0", "remote1", "remote2", "remote3"
};

static const char *maxim4c_remote_link_compat[MAXIM4C_LINK_ID_MAX] = {
	"maxim4c,link0", "maxim4c,link1", "maxim4c,link2", "maxim4c,link3"
};

static int maxim4c_remote_dev_info_parse(struct device *dev,
			struct mfd_cell *remote_mfd_dev, u8 link_id)
{
	struct device_node *node = NULL;
	const char *remote_device_name = "serdes-remote-device";
	const char *prop_str = NULL, *link_compat = NULL;
	u32 sub_idx = 0, remote_id = 0;
	int ret = 0;

	node = NULL;
	sub_idx = 0;
	while ((node = of_get_next_child(dev->of_node, node))) {
		if (!strncasecmp(node->name,
					remote_device_name,
					strlen(remote_device_name))) {
			if (sub_idx >= MAXIM4C_LINK_ID_MAX) {
				dev_err(dev, "%pOF: Too many matching %s node\n",
						dev->of_node, remote_device_name);

				of_node_put(node);
				break;
			}

			if (!of_device_is_available(node)) {
				dev_info(dev, "%pOF is disabled\n", node);

				sub_idx++;

				continue;
			}

			/* remote id */
			ret = of_property_read_u32(node, "remote-id", &remote_id);
			if (ret) {
				sub_idx++;

				continue;
			}
			if (remote_id >= MAXIM4C_LINK_ID_MAX) {
				sub_idx++;

				continue;
			}

			if (remote_id != link_id) {
				sub_idx++;

				continue;
			}

			dev_info(dev, "remote device id = %d\n", remote_id);

			ret = of_property_read_string(node, "compatible", &prop_str);
			if (ret) {
				dev_err(dev, "%pOF no compatible error\n", node);

				of_node_put(node);
				return -EINVAL;
			}

			link_compat = maxim4c_remote_link_compat[remote_id];
			if (!strncasecmp(prop_str,
					link_compat, strlen(link_compat))) {
				dev_info(dev, "compatible property: %s\n", prop_str);

				remote_mfd_dev->name = maxim4c_remote_devs_name[remote_id];
				remote_mfd_dev->of_compatible = prop_str;

				of_node_put(node);
				return 0;
			}

			dev_err(dev, "%pOF compatible and remote_id mismatch\n", node);

			of_node_put(node);
			return -EINVAL;
		}
	}

	return -EINVAL;
}

static int maxim4c_remote_mfd_devs_init(maxim4c_t *maxim4c)
{
	struct device *dev = &maxim4c->client->dev;
	maxim4c_gmsl_link_t *gmsl_link = &maxim4c->gmsl_link;
	struct mfd_cell *remote_mfd_dev = NULL;
	int link_idx = 0, nr_mfd_cell = 0;
	int ret = 0;

	remote_mfd_dev = maxim4c->remote_mfd_devs;
	nr_mfd_cell = 0;
	for (link_idx = 0; link_idx < MAXIM4C_LINK_ID_MAX; link_idx++) {
		remote_mfd_dev->name = NULL;
		remote_mfd_dev->of_compatible = NULL;

		if (gmsl_link->link_cfg[link_idx].link_enable == 0) {
			dev_dbg(dev, "%s: link id = %d is disabled\n",
					__func__, link_idx);
			continue;
		}

		ret = maxim4c_remote_dev_info_parse(dev, remote_mfd_dev, link_idx);
		if (ret == 0) {
			remote_mfd_dev++;
			nr_mfd_cell++;
		}
	}

	dev_info(dev, "Total number of remote devices is %d", nr_mfd_cell);

	return nr_mfd_cell;
}

int maxim4c_remote_mfd_add_devices(maxim4c_t *maxim4c)
{
	struct device *dev = &maxim4c->client->dev;
	int nr_mfd_cell = 0, ret = 0;

	dev_info(dev, "=== maxim4c add remote devices ===");

	nr_mfd_cell = maxim4c_remote_mfd_devs_init(maxim4c);
	if (nr_mfd_cell == 0) {
		dev_err(dev, "%s: remote mfd devices init error\n",
				__func__);
		return -EINVAL;
	}

	ret = devm_mfd_add_devices(dev, PLATFORM_DEVID_AUTO,
			maxim4c->remote_mfd_devs, nr_mfd_cell,
			NULL, 0, NULL);
	if (ret)
		dev_err(dev, "%s: add remote mfd devices error: %d\n",
				__func__, ret);

	return ret;
}
EXPORT_SYMBOL(maxim4c_remote_mfd_add_devices);

int maxim4c_remote_devices_init(maxim4c_t *maxim4c, u8 link_init_mask)
{
	struct device *dev = &maxim4c->client->dev;
	struct maxim4c_remote *remote_device = NULL;
	const struct maxim4c_remote_ops *remote_ops = NULL;
	u8 link_mask = 0, link_enable = 0, link_locked = 0;
	int ret = 0, i = 0;

	dev_dbg(dev, "%s: link init mask = 0x%02x\n", __func__, link_init_mask);

	for (i = 0; i < MAXIM4C_LINK_ID_MAX; i++) {
		if ((link_init_mask & BIT(i)) == 0) {
			dev_dbg(dev, "link id = %d init mask is disabled\n", i);
			continue;
		}

		link_enable = maxim4c->gmsl_link.link_cfg[i].link_enable;
		if (link_enable == 0) {
			dev_info(dev, "link id = %d is disabled\n", i);
			continue;
		}

		remote_device = maxim4c->remote_device[i];
		if (remote_device == NULL) {
			dev_info(dev, "remote device id = %d isn't detected\n", i);
			continue;
		}

		if (remote_device->remote_enable == 0) {
			dev_info(dev, "remote device id = %d isn't enabled\n", i);
			continue;
		}

		remote_ops = remote_device->remote_ops;
		if (remote_ops == NULL) {
			dev_info(dev, "remote device id = %d is no ops\n", i);
			continue;
		}

		link_mask = BIT(i);
		link_locked = maxim4c_link_get_lock_state(maxim4c, link_mask);
		if (link_locked != link_mask) {
			dev_info(dev, "link id = %d is unlocked\n", i);
			continue;
		}

		maxim4c_link_select_remote_control(maxim4c, link_mask);

		if (remote_ops->remote_init)
			ret |= remote_ops->remote_init(remote_device);
	}

	return ret;
}
EXPORT_SYMBOL(maxim4c_remote_devices_init);

int maxim4c_remote_devices_deinit(maxim4c_t *maxim4c, u8 link_init_mask)
{
	struct device *dev = &maxim4c->client->dev;
	struct maxim4c_remote *remote_device = NULL;
	const struct maxim4c_remote_ops *remote_ops = NULL;
	u8 link_mask = 0, link_enable = 0, link_locked = 0;
	int ret = 0, i = 0;

	dev_dbg(dev, "%s: link init mask = 0x%02x\n", __func__, link_init_mask);

	for (i = 0; i < MAXIM4C_LINK_ID_MAX; i++) {
		if ((link_init_mask & BIT(i)) == 0) {
			dev_dbg(dev, "link id = %d init mask is disabled\n", i);
			continue;
		}

		link_enable = maxim4c->gmsl_link.link_cfg[i].link_enable;
		if (link_enable == 0) {
			dev_info(dev, "link id = %d is disabled\n", i);
			continue;
		}

		remote_device = maxim4c->remote_device[i];
		if (remote_device == NULL) {
			dev_info(dev, "remote device id = %d isn't detected\n", i);
			continue;
		}

		if (remote_device->remote_enable == 0) {
			dev_info(dev, "remote device id = %d isn't enabled\n", i);
			continue;
		}

		remote_ops = remote_device->remote_ops;
		if (remote_ops == NULL) {
			dev_info(dev, "remote device id = %d is no ops\n", i);
			continue;
		}

		link_mask = BIT(i);
		link_locked = maxim4c_link_get_lock_state(maxim4c, link_mask);
		if (link_locked != link_mask) {
			dev_info(dev, "link id = %d is unlocked\n", i);
			continue;
		}

		maxim4c_link_select_remote_control(maxim4c, link_mask);

		if (remote_ops->remote_deinit)
			ret |= remote_ops->remote_deinit(remote_device);
	}

	return ret;
}
EXPORT_SYMBOL(maxim4c_remote_devices_deinit);

int maxim4c_remote_load_init_seq(maxim4c_remote_t *remote_device)
{
	struct device *dev = remote_device->dev;
	struct device_node *node = NULL;
	int ret = 0;

	node = of_get_child_by_name(dev->of_node, "remote-init-sequence");
	if (!IS_ERR_OR_NULL(node)) {
		dev_info(dev, "load remote-init-sequence\n");

		ret = maxim4c_i2c_load_init_seq(dev, node,
					&remote_device->remote_init_seq);

		of_node_put(node);
		return ret;
	}

	return 0;
}
EXPORT_SYMBOL(maxim4c_remote_load_init_seq);

int maxim4c_remote_i2c_addr_select(maxim4c_remote_t *remote_device, u32 i2c_id)
{
	struct device *dev = remote_device->dev;
	struct i2c_client *client = remote_device->client;

	if (i2c_id == MAXIM4C_I2C_SER_DEF) {
		client->addr = remote_device->ser_i2c_addr_def;
		dev_info(dev, "ser select default i2c addr = 0x%02x\n", client->addr);
	} else if (i2c_id == MAXIM4C_I2C_SER_MAP) {
		client->addr = remote_device->ser_i2c_addr_map;
		dev_info(dev, "ser select mapping i2c addr = 0x%02x\n", client->addr);
	} else {
		dev_err(dev, "i2c select id = %d error\n", i2c_id);
		return -EINVAL;
	}

	return 0;
}
EXPORT_SYMBOL(maxim4c_remote_i2c_addr_select);

int maxim4c_remote_i2c_client_init(maxim4c_remote_t *remote_device,
				struct i2c_client *des_client)
{
	struct device *dev = remote_device->dev;
	struct i2c_client *ser_client = NULL;
	u16 ser_client_addr = 0;

	if (remote_device->ser_i2c_addr_map)
		ser_client_addr = remote_device->ser_i2c_addr_map;
	else
		ser_client_addr = remote_device->ser_i2c_addr_def;
	ser_client = devm_i2c_new_dummy_device(&des_client->dev,
				des_client->adapter, ser_client_addr);
	if (IS_ERR(ser_client)) {
		dev_err(dev, "failed to alloc i2c client.\n");
		return -PTR_ERR(ser_client);
	}
	ser_client->addr = remote_device->ser_i2c_addr_def;

	remote_device->client = ser_client;
	i2c_set_clientdata(ser_client, remote_device);

	dev_info(dev, "remote i2c client init, i2c_addr = 0x%02x\n",
			ser_client_addr);

	return 0;
}
EXPORT_SYMBOL(maxim4c_remote_i2c_client_init);

static int maxim4c_remote_device_chain_check(maxim4c_remote_t *remote_device)
{
	struct device *dev = NULL;
	struct device_node *endpoint = NULL;
	struct device_node *link_node = NULL;
	u8 remote_id, link_id;
	u32 value;
	int ret = 0;

	if (remote_device == NULL) {
		dev_err(dev, "%s: input parameter is error\n", __func__);
		return -EINVAL;
	}

	dev = remote_device->dev;
	remote_id = remote_device->remote_id;

	endpoint = of_graph_get_next_endpoint(dev->of_node, NULL);
	if (!endpoint) {
		dev_err(dev, "%s: no endpoint error\n", __func__);
		return -EINVAL;
	}

	link_node = of_graph_get_remote_port_parent(endpoint);
	if (!link_node) {
		dev_err(dev, "%pOF: endpoint has no remote port parent error\n",
				endpoint);
		return -EINVAL;
	}

	ret = of_property_read_u32(link_node, "link-id", &value);
	if (ret) {
		dev_err(dev, "%pOF: no property link_id error\n", link_node);

		of_node_put(link_node);
		return -EINVAL;
	}
	of_node_put(link_node);
	link_id = value;

	if (remote_id != link_id) {
		dev_err(dev, "remote_id (%d) != link_id (%d) of %pOF\n",
				remote_id, link_id, link_node);
		return -EINVAL;
	}

	return 0;
}

int maxim4c_remote_device_register(maxim4c_t *maxim4c,
		maxim4c_remote_t *remote_device)
{
	struct device *dev = NULL;
	u8 remote_id;
	int ret = 0;

	if ((maxim4c == NULL) || (remote_device == NULL)) {
		dev_err(dev, "%s: input parameter is error!\n", __func__);

		return -EINVAL;
	}

	dev = remote_device->dev;
	remote_id = remote_device->remote_id;
	if (remote_id >= MAXIM4C_LINK_ID_MAX) {
		dev_err(dev, "%s: remote_id = %d is error\n",
				__func__, remote_id);

		return -EINVAL;
	}

	if (maxim4c->remote_device[remote_id] != NULL) {
		dev_err(dev, "%s: remote_id = %d is conflict\n",
				__func__, remote_id);

		return -EINVAL;
	}

	ret = maxim4c_remote_device_chain_check(remote_device);
	if (ret) {
		dev_err(dev, "%s: remote device id = %d chain error\n",
				__func__, remote_id);
		return -EINVAL;
	}

	remote_device->remote_enable = 1;
	maxim4c->remote_device[remote_id] = remote_device;

	return 0;
}
EXPORT_SYMBOL(maxim4c_remote_device_register);