[mirror_ubuntu-jammy-kernel.git] / drivers / net / dsa / xrs700x / xrs700x_i2c.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2020 NovaTech LLC
 * George McCollister <george.mccollister@gmail.com>
 */

#include <linux/bits.h>
#include <linux/i2c.h>
#include <linux/module.h>
#include "xrs700x.h"
#include "xrs700x_reg.h"

struct xrs700x_i2c_cmd {
	__be32 reg;
	__be16 val;
} __packed;

static int xrs700x_i2c_reg_read(void *context, unsigned int reg,
				unsigned int *val)
{
	struct device *dev = context;
	struct i2c_client *i2c = to_i2c_client(dev);
	struct xrs700x_i2c_cmd cmd;
	int ret;

	cmd.reg = cpu_to_be32(reg | 1);

	ret = i2c_master_send(i2c, (char *)&cmd.reg, sizeof(cmd.reg));
	if (ret < 0) {
		dev_err(dev, "xrs i2c_master_send returned %d\n", ret);
		return ret;
	}

	ret = i2c_master_recv(i2c, (char *)&cmd.val, sizeof(cmd.val));
	if (ret < 0) {
		dev_err(dev, "xrs i2c_master_recv returned %d\n", ret);
		return ret;
	}

	*val = be16_to_cpu(cmd.val);
	return 0;
}

static int xrs700x_i2c_reg_write(void *context, unsigned int reg,
				 unsigned int val)
{
	struct device *dev = context;
	struct i2c_client *i2c = to_i2c_client(dev);
	struct xrs700x_i2c_cmd cmd;
	int ret;

	cmd.reg = cpu_to_be32(reg);
	cmd.val = cpu_to_be16(val);

	ret = i2c_master_send(i2c, (char *)&cmd, sizeof(cmd));
	if (ret < 0) {
		dev_err(dev, "xrs i2c_master_send returned %d\n", ret);
		return ret;
	}

	return 0;
}

static const struct regmap_config xrs700x_i2c_regmap_config = {
	.val_bits = 16,
	.reg_stride = 2,
	.reg_bits = 32,
	.pad_bits = 0,
	.write_flag_mask = 0,
	.read_flag_mask = 0,
	.reg_read = xrs700x_i2c_reg_read,
	.reg_write = xrs700x_i2c_reg_write,
	.max_register = 0,
	.cache_type = REGCACHE_NONE,
	.reg_format_endian = REGMAP_ENDIAN_BIG,
	.val_format_endian = REGMAP_ENDIAN_BIG
};

static int xrs700x_i2c_probe(struct i2c_client *i2c,
			     const struct i2c_device_id *i2c_id)
{
	struct xrs700x *priv;
	int ret;

	priv = xrs700x_switch_alloc(&i2c->dev, i2c);
	if (!priv)
		return -ENOMEM;

	priv->regmap = devm_regmap_init(&i2c->dev, NULL, &i2c->dev,
					&xrs700x_i2c_regmap_config);
	if (IS_ERR(priv->regmap)) {
		ret = PTR_ERR(priv->regmap);
		dev_err(&i2c->dev, "Failed to initialize regmap: %d\n", ret);
		return ret;
	}

	i2c_set_clientdata(i2c, priv);

	ret = xrs700x_switch_register(priv);

	/* Main DSA driver may not be started yet. */
	if (ret)
		return ret;

	return 0;
}

static int xrs700x_i2c_remove(struct i2c_client *i2c)
{
	struct xrs700x *priv = i2c_get_clientdata(i2c);

	if (!priv)
		return 0;

	xrs700x_switch_remove(priv);

	i2c_set_clientdata(i2c, NULL);

	return 0;
}

static void xrs700x_i2c_shutdown(struct i2c_client *i2c)
{
	struct xrs700x *priv = i2c_get_clientdata(i2c);

	if (!priv)
		return;

	xrs700x_switch_shutdown(priv);

	i2c_set_clientdata(i2c, NULL);
}

static const struct i2c_device_id xrs700x_i2c_id[] = {
	{ "xrs700x-switch", 0 },
	{},
};

MODULE_DEVICE_TABLE(i2c, xrs700x_i2c_id);

static const struct of_device_id __maybe_unused xrs700x_i2c_dt_ids[] = {
	{ .compatible = "arrow,xrs7003e", .data = &xrs7003e_info },
	{ .compatible = "arrow,xrs7003f", .data = &xrs7003f_info },
	{ .compatible = "arrow,xrs7004e", .data = &xrs7004e_info },
	{ .compatible = "arrow,xrs7004f", .data = &xrs7004f_info },
	{},
};
MODULE_DEVICE_TABLE(of, xrs700x_i2c_dt_ids);

static struct i2c_driver xrs700x_i2c_driver = {
	.driver = {
		.name	= "xrs700x-i2c",
		.of_match_table = of_match_ptr(xrs700x_i2c_dt_ids),
	},
	.probe	= xrs700x_i2c_probe,
	.remove	= xrs700x_i2c_remove,
	.shutdown = xrs700x_i2c_shutdown,
	.id_table = xrs700x_i2c_id,
};

module_i2c_driver(xrs700x_i2c_driver);

MODULE_AUTHOR("George McCollister <george.mccollister@gmail.com>");
MODULE_DESCRIPTION("Arrow SpeedChips XRS700x DSA I2C driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
ee00b24f GM	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Copyright (C) 2020 NovaTech LLC
	4	* George McCollister <george.mccollister@gmail.com>
	5	*/
	6
	7	#include <linux/bits.h>
	8	#include <linux/i2c.h>
	9	#include <linux/module.h>
	10	#include "xrs700x.h"
	11	#include "xrs700x_reg.h"
	12
add285bc TW	13	struct xrs700x_i2c_cmd {
	14	__be32 reg;
	15	__be16 val;
	16	} __packed;
	17
ee00b24f GM	18	static int xrs700x_i2c_reg_read(void *context, unsigned int reg,
	19	unsigned int *val)
	20	{
	21	struct device *dev = context;
	22	struct i2c_client *i2c = to_i2c_client(dev);
add285bc	23	struct xrs700x_i2c_cmd cmd;
ee00b24f GM	24	int ret;
ee00b24f GM	25
add285bc	26	cmd.reg = cpu_to_be32(reg \| 1);
ee00b24f	27
add285bc	28	ret = i2c_master_send(i2c, (char *)&cmd.reg, sizeof(cmd.reg));
ee00b24f GM	29	if (ret < 0) {
	30	dev_err(dev, "xrs i2c_master_send returned %d\n", ret);
	31	return ret;
	32	}
	33
add285bc	34	ret = i2c_master_recv(i2c, (char *)&cmd.val, sizeof(cmd.val));
ee00b24f GM	35	if (ret < 0) {
	36	dev_err(dev, "xrs i2c_master_recv returned %d\n", ret);
	37	return ret;
	38	}
	39
add285bc	40	*val = be16_to_cpu(cmd.val);
ee00b24f GM	41	return 0;
	42	}
	43
	44	static int xrs700x_i2c_reg_write(void *context, unsigned int reg,
	45	unsigned int val)
	46	{
	47	struct device *dev = context;
	48	struct i2c_client *i2c = to_i2c_client(dev);
add285bc	49	struct xrs700x_i2c_cmd cmd;
ee00b24f GM	50	int ret;
ee00b24f GM	51
add285bc TW	52	cmd.reg = cpu_to_be32(reg);
add285bc TW	53	cmd.val = cpu_to_be16(val);
ee00b24f	54
add285bc	55	ret = i2c_master_send(i2c, (char *)&cmd, sizeof(cmd));
ee00b24f GM	56	if (ret < 0) {
	57	dev_err(dev, "xrs i2c_master_send returned %d\n", ret);
	58	return ret;
	59	}
	60
	61	return 0;
	62	}
	63
	64	static const struct regmap_config xrs700x_i2c_regmap_config = {
	65	.val_bits = 16,
	66	.reg_stride = 2,
	67	.reg_bits = 32,
	68	.pad_bits = 0,
	69	.write_flag_mask = 0,
	70	.read_flag_mask = 0,
	71	.reg_read = xrs700x_i2c_reg_read,
	72	.reg_write = xrs700x_i2c_reg_write,
	73	.max_register = 0,
	74	.cache_type = REGCACHE_NONE,
	75	.reg_format_endian = REGMAP_ENDIAN_BIG,
	76	.val_format_endian = REGMAP_ENDIAN_BIG
	77	};
	78
	79	static int xrs700x_i2c_probe(struct i2c_client *i2c,
	80	const struct i2c_device_id *i2c_id)
	81	{
	82	struct xrs700x *priv;
	83	int ret;
	84
	85	priv = xrs700x_switch_alloc(&i2c->dev, i2c);
	86	if (!priv)
	87	return -ENOMEM;
	88
	89	priv->regmap = devm_regmap_init(&i2c->dev, NULL, &i2c->dev,
	90	&xrs700x_i2c_regmap_config);
	91	if (IS_ERR(priv->regmap)) {
	92	ret = PTR_ERR(priv->regmap);
	93	dev_err(&i2c->dev, "Failed to initialize regmap: %d\n", ret);
	94	return ret;
	95	}
	96
	97	i2c_set_clientdata(i2c, priv);
	98
	99	ret = xrs700x_switch_register(priv);
	100
	101	/* Main DSA driver may not be started yet. */
	102	if (ret)
	103	return ret;
	104
	105	return 0;
	106	}
	107
	108	static int xrs700x_i2c_remove(struct i2c_client *i2c)
	109	{
	110	struct xrs700x *priv = i2c_get_clientdata(i2c);
	111
a68e9da4 VO	112	if (!priv)
	113	return 0;
	114
ee00b24f GM	115	xrs700x_switch_remove(priv);
ee00b24f GM	116
a68e9da4 VO	117	i2c_set_clientdata(i2c, NULL);
a68e9da4 VO	118
ee00b24f GM	119	return 0;
	120	}
	121
a68e9da4 VO	122	static void xrs700x_i2c_shutdown(struct i2c_client *i2c)
	123	{
	124	struct xrs700x *priv = i2c_get_clientdata(i2c);
	125
	126	if (!priv)
	127	return;
	128
	129	xrs700x_switch_shutdown(priv);
	130
	131	i2c_set_clientdata(i2c, NULL);
	132	}
	133
ee00b24f GM	134	static const struct i2c_device_id xrs700x_i2c_id[] = {
	135	{ "xrs700x-switch", 0 },
	136	{},
	137	};
	138
	139	MODULE_DEVICE_TABLE(i2c, xrs700x_i2c_id);
	140
3e0103a3	141	static const struct of_device_id __maybe_unused xrs700x_i2c_dt_ids[] = {
ee00b24f GM	142	{ .compatible = "arrow,xrs7003e", .data = &xrs7003e_info },
	143	{ .compatible = "arrow,xrs7003f", .data = &xrs7003f_info },
	144	{ .compatible = "arrow,xrs7004e", .data = &xrs7004e_info },
	145	{ .compatible = "arrow,xrs7004f", .data = &xrs7004f_info },
	146	{},
	147	};
	148	MODULE_DEVICE_TABLE(of, xrs700x_i2c_dt_ids);
	149
	150	static struct i2c_driver xrs700x_i2c_driver = {
	151	.driver = {
	152	.name = "xrs700x-i2c",
	153	.of_match_table = of_match_ptr(xrs700x_i2c_dt_ids),
	154	},
	155	.probe = xrs700x_i2c_probe,
	156	.remove = xrs700x_i2c_remove,
a68e9da4	157	.shutdown = xrs700x_i2c_shutdown,
ee00b24f GM	158	.id_table = xrs700x_i2c_id,
	159	};
	160
	161	module_i2c_driver(xrs700x_i2c_driver);
	162
	163	MODULE_AUTHOR("George McCollister <george.mccollister@gmail.com>");
	164	MODULE_DESCRIPTION("Arrow SpeedChips XRS700x DSA I2C driver");
	165	MODULE_LICENSE("GPL v2");