[u-boot.git] / drivers / sysinfo / rcar3.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2021 Marek Vasut <[email protected]>
 */

#include <dm.h>
#include <i2c_eeprom.h>
#include <log.h>
#include <sysinfo.h>

#define BOARD_CODE_MASK		0xF8
#define BOARD_REV_MASK		0x07
#define BOARD_CODE_SHIFT	0x03

#define BOARD_SALVATOR_X	0x0
#define BOARD_KRIEK		0x1
#define BOARD_STARTER_KIT	0x2
#define BOARD_EAGLE		0x3
#define BOARD_SALVATOR_XS	0x4
#define BOARD_CONDOR		0x6
#define BOARD_DRAAK		0x7
#define BOARD_EBISU		0x8
#define BOARD_STARTER_KIT_PRE	0xB
#define BOARD_EBISU_4D		0xD
#define BOARD_CONDOR_I		0x10

/**
 * struct sysinfo_rcar_priv - sysinfo private data
 * @boardname: board model and revision
 * @val: board ID value from eeprom
 */
struct sysinfo_rcar_priv {
	char	boardmodel[64];
	u8	val;
};

static int sysinfo_rcar_detect(struct udevice *dev)
{
	struct sysinfo_rcar_priv *priv = dev_get_priv(dev);

	return priv->val == 0xff;
}

static int sysinfo_rcar_get_str(struct udevice *dev, int id, size_t size, char *val)
{
	struct sysinfo_rcar_priv *priv = dev_get_priv(dev);

	switch (id) {
	case SYSINFO_ID_BOARD_MODEL:
		strncpy(val, priv->boardmodel, size);
		val[size - 1] = '\0';
		return 0;
	default:
		return -EINVAL;
	};
}

static const struct sysinfo_ops sysinfo_rcar_ops = {
	.detect = sysinfo_rcar_detect,
	.get_str = sysinfo_rcar_get_str,
};

static void sysinfo_rcar_parse(struct sysinfo_rcar_priv *priv)
{
	const u8 board_id = (priv->val & BOARD_CODE_MASK) >> BOARD_CODE_SHIFT;
	const u8 board_rev = priv->val & BOARD_REV_MASK;
	bool salvator_xs = false;
	bool ebisu_4d = false;
	bool condor_i = false;
	char rev_major = '?';
	char rev_minor = '?';

	switch (board_id) {
	case BOARD_SALVATOR_XS:
		salvator_xs = true;
		fallthrough;
	case BOARD_SALVATOR_X:
		if (!(board_rev & ~1)) { /* Only rev 0 and 1 is valid */
			rev_major = '1';
			rev_minor = '0' + (board_rev & BIT(0));
		}
		snprintf(priv->boardmodel, sizeof(priv->boardmodel),
			 "Renesas Salvator-X%s board rev %c.%c",
			 salvator_xs ? "S" : "", rev_major, rev_minor);
		return;
	case BOARD_STARTER_KIT:
		if (!(board_rev & ~1)) { /* Only rev 0 and 1 is valid */
			rev_major = (board_rev & BIT(0)) ? '3' : '1';
			rev_minor = '0';
		}
		snprintf(priv->boardmodel, sizeof(priv->boardmodel),
			 "Renesas Starter Kit board rev %c.%c",
			 rev_major, rev_minor);
		return;
	case BOARD_STARTER_KIT_PRE:
		if (!(board_rev & ~3)) { /* Only rev 0..3 is valid */
			rev_major = (board_rev & BIT(1)) ? '2' : '1';
			rev_minor = (board_rev == 3) ? '1' : '0';
		}
		snprintf(priv->boardmodel, sizeof(priv->boardmodel),
			 "Renesas Starter Kit Premier board rev %c.%c",
			 rev_major, rev_minor);
		return;
	case BOARD_EAGLE:
		if (!board_rev) { /* Only rev 0 is valid */
			rev_major = '1';
			rev_minor = '0';
		}
		snprintf(priv->boardmodel, sizeof(priv->boardmodel),
			 "Renesas Eagle board rev %c.%c",
			 rev_major, rev_minor);
		return;
	case BOARD_EBISU_4D:
		ebisu_4d = true;
		fallthrough;
	case BOARD_EBISU:
		if (!board_rev) { /* Only rev 0 is valid */
			rev_major = '1';
			rev_minor = '0';
		}
		snprintf(priv->boardmodel, sizeof(priv->boardmodel),
			 "Renesas Ebisu%s board rev %c.%c",
			 ebisu_4d ? "-4D" : "", rev_major, rev_minor);
		return;
	case BOARD_DRAAK:
		if (!board_rev) { /* Only rev 0 is valid */
			rev_major = '1';
			rev_minor = '0';
		}
		snprintf(priv->boardmodel, sizeof(priv->boardmodel),
			 "Renesas Draak board rev %c.%c",
			 rev_major, rev_minor);
		return;
	case BOARD_KRIEK:
		if (!board_rev) { /* Only rev 0 is valid */
			rev_major = '1';
			rev_minor = '0';
		}
		snprintf(priv->boardmodel, sizeof(priv->boardmodel),
			 "Renesas Kriek board rev %c.%c",
			 rev_major, rev_minor);
		return;
	case BOARD_CONDOR_I:
		condor_i = true;
		fallthrough;
	case BOARD_CONDOR:
		if (!board_rev) { /* Only rev 0 is valid */
			rev_major = '1';
			rev_minor = '0';
		}
		snprintf(priv->boardmodel, sizeof(priv->boardmodel),
			"Renesas Condor%s board rev %c.%c",
			condor_i ? "-I" : "", rev_major, rev_minor);
		return;
	default:
		snprintf(priv->boardmodel, sizeof(priv->boardmodel),
			 "Renesas -Unknown- board rev ?.?");
		priv->val = 0xff;
		return;
	}
}

static int sysinfo_rcar_probe(struct udevice *dev)
{
	struct sysinfo_rcar_priv *priv = dev_get_priv(dev);
	struct ofnode_phandle_args phandle_args;
	struct udevice *i2c_eeprom;
	u32 offset;
	int ret;

	offset = dev_read_u32_default(dev, "offset", 0x70);

	ret = dev_read_phandle_with_args(dev, "i2c-eeprom", NULL,
					 0, 0, &phandle_args);
	if (ret) {
		debug("%s: i2c-eeprom backing device not specified\n",
		      dev->name);
		return ret;
	}

	ret = uclass_get_device_by_ofnode(UCLASS_I2C_EEPROM, phandle_args.node,
					  &i2c_eeprom);
	if (ret) {
		debug("%s: could not get backing device\n", dev->name);
		return ret;
	}

	ret = i2c_eeprom_read(i2c_eeprom, offset, &priv->val, 1);
	if (ret < 0) {
		debug("%s: read failed\n", __func__);
		return -EIO;
	}

	sysinfo_rcar_parse(priv);

	return 0;
}

static const struct udevice_id sysinfo_rcar_ids[] = {
	{ .compatible = "renesas,rcar-sysinfo" },
	{ /* sentinel */ }
};

U_BOOT_DRIVER(sysinfo_rcar) = {
	.name           = "sysinfo_rcar",
	.id             = UCLASS_SYSINFO,
	.of_match       = sysinfo_rcar_ids,
	.ops		= &sysinfo_rcar_ops,
	.priv_auto	= sizeof(struct sysinfo_rcar_priv),
	.probe          = sysinfo_rcar_probe,
};
Commit	Line	Data
85cd345d MV	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Copyright (C) 2021 Marek Vasut <[email protected]>
	4	*/
	5
85cd345d MV	6	#include <dm.h>
	7	#include <i2c_eeprom.h>
	8	#include <log.h>
	9	#include <sysinfo.h>
	10
	11	#define BOARD_CODE_MASK 0xF8
	12	#define BOARD_REV_MASK 0x07
	13	#define BOARD_CODE_SHIFT 0x03
	14
	15	#define BOARD_SALVATOR_X 0x0
	16	#define BOARD_KRIEK 0x1
	17	#define BOARD_STARTER_KIT 0x2
b791b9cf	18	#define BOARD_EAGLE 0x3
85cd345d	19	#define BOARD_SALVATOR_XS 0x4
c8eaebb4	20	#define BOARD_CONDOR 0x6
b791b9cf	21	#define BOARD_DRAAK 0x7
85cd345d MV	22	#define BOARD_EBISU 0x8
	23	#define BOARD_STARTER_KIT_PRE 0xB
	24	#define BOARD_EBISU_4D 0xD
c8eaebb4	25	#define BOARD_CONDOR_I 0x10
85cd345d MV	26
	27	/**
	28	* struct sysinfo_rcar_priv - sysinfo private data
	29	* @boardname: board model and revision
	30	* @val: board ID value from eeprom
	31	*/
	32	struct sysinfo_rcar_priv {
	33	char boardmodel[64];
	34	u8 val;
	35	};
	36
	37	static int sysinfo_rcar_detect(struct udevice *dev)
	38	{
	39	struct sysinfo_rcar_priv *priv = dev_get_priv(dev);
	40
	41	return priv->val == 0xff;
	42	}
	43
	44	static int sysinfo_rcar_get_str(struct udevice dev, int id, size_t size, char val)
	45	{
	46	struct sysinfo_rcar_priv *priv = dev_get_priv(dev);
	47
	48	switch (id) {
	49	case SYSINFO_ID_BOARD_MODEL:
	50	strncpy(val, priv->boardmodel, size);
	51	val[size - 1] = '\0';
	52	return 0;
	53	default:
	54	return -EINVAL;
	55	};
	56	}
	57
	58	static const struct sysinfo_ops sysinfo_rcar_ops = {
	59	.detect = sysinfo_rcar_detect,
	60	.get_str = sysinfo_rcar_get_str,
	61	};
	62
	63	static void sysinfo_rcar_parse(struct sysinfo_rcar_priv *priv)
	64	{
	65	const u8 board_id = (priv->val & BOARD_CODE_MASK) >> BOARD_CODE_SHIFT;
	66	const u8 board_rev = priv->val & BOARD_REV_MASK;
	67	bool salvator_xs = false;
	68	bool ebisu_4d = false;
c8eaebb4	69	bool condor_i = false;
85cd345d MV	70	char rev_major = '?';
	71	char rev_minor = '?';
	72
	73	switch (board_id) {
	74	case BOARD_SALVATOR_XS:
	75	salvator_xs = true;
	76	fallthrough;
	77	case BOARD_SALVATOR_X:
	78	if (!(board_rev & ~1)) { /* Only rev 0 and 1 is valid */
	79	rev_major = '1';
	80	rev_minor = '0' + (board_rev & BIT(0));
	81	}
	82	snprintf(priv->boardmodel, sizeof(priv->boardmodel),
	83	"Renesas Salvator-X%s board rev %c.%c",
	84	salvator_xs ? "S" : "", rev_major, rev_minor);
	85	return;
	86	case BOARD_STARTER_KIT:
	87	if (!(board_rev & ~1)) { /* Only rev 0 and 1 is valid */
	88	rev_major = (board_rev & BIT(0)) ? '3' : '1';
	89	rev_minor = '0';
	90	}
	91	snprintf(priv->boardmodel, sizeof(priv->boardmodel),
	92	"Renesas Starter Kit board rev %c.%c",
	93	rev_major, rev_minor);
	94	return;
	95	case BOARD_STARTER_KIT_PRE:
	96	if (!(board_rev & ~3)) { /* Only rev 0..3 is valid */
	97	rev_major = (board_rev & BIT(1)) ? '2' : '1';
	98	rev_minor = (board_rev == 3) ? '1' : '0';
	99	}
	100	snprintf(priv->boardmodel, sizeof(priv->boardmodel),
	101	"Renesas Starter Kit Premier board rev %c.%c",
	102	rev_major, rev_minor);
	103	return;
	104	case BOARD_EAGLE:
	105	if (!board_rev) { /* Only rev 0 is valid */
	106	rev_major = '1';
	107	rev_minor = '0';
	108	}
	109	snprintf(priv->boardmodel, sizeof(priv->boardmodel),
	110	"Renesas Eagle board rev %c.%c",
	111	rev_major, rev_minor);
	112	return;
	113	case BOARD_EBISU_4D:
	114	ebisu_4d = true;
	115	fallthrough;
	116	case BOARD_EBISU:
	117	if (!board_rev) { /* Only rev 0 is valid */
	118	rev_major = '1';
	119	rev_minor = '0';
	120	}
	121	snprintf(priv->boardmodel, sizeof(priv->boardmodel),
	122	"Renesas Ebisu%s board rev %c.%c",
	123	ebisu_4d ? "-4D" : "", rev_major, rev_minor);
	124	return;
	125	case BOARD_DRAAK:
	126	if (!board_rev) { /* Only rev 0 is valid */
	127	rev_major = '1';
	128	rev_minor = '0';
	129	}
	130	snprintf(priv->boardmodel, sizeof(priv->boardmodel),
	131	"Renesas Draak board rev %c.%c",
	132	rev_major, rev_minor);
	133	return;
134	case BOARD_KRIEK:
135	if (!board_rev) { /* Only rev 0 is valid */
136	rev_major = '1';
137	rev_minor = '0';
138	}
139	snprintf(priv->boardmodel, sizeof(priv->boardmodel),
140	"Renesas Kriek board rev %c.%c",
141	rev_major, rev_minor);
142	return;
c8eaebb4 TN	143	case BOARD_CONDOR_I:
	144	condor_i = true;
	145	fallthrough;
	146	case BOARD_CONDOR:
	147	if (!board_rev) { /* Only rev 0 is valid */
	148	rev_major = '1';
	149	rev_minor = '0';
	150	}
	151	snprintf(priv->boardmodel, sizeof(priv->boardmodel),
	152	"Renesas Condor%s board rev %c.%c",
	153	condor_i ? "-I" : "", rev_major, rev_minor);
	154	return;
85cd345d MV	155	default:
	156	snprintf(priv->boardmodel, sizeof(priv->boardmodel),
	157	"Renesas -Unknown- board rev ?.?");
	158	priv->val = 0xff;
	159	return;
	160	}
	161	}
	162
	163	static int sysinfo_rcar_probe(struct udevice *dev)
	164	{
	165	struct sysinfo_rcar_priv *priv = dev_get_priv(dev);
	166	struct ofnode_phandle_args phandle_args;
	167	struct udevice *i2c_eeprom;
	168	u32 offset;
	169	int ret;
	170
	171	offset = dev_read_u32_default(dev, "offset", 0x70);
	172
	173	ret = dev_read_phandle_with_args(dev, "i2c-eeprom", NULL,
	174	0, 0, &phandle_args);
	175	if (ret) {
	176	debug("%s: i2c-eeprom backing device not specified\n",
	177	dev->name);
	178	return ret;
	179	}
	180
	181	ret = uclass_get_device_by_ofnode(UCLASS_I2C_EEPROM, phandle_args.node,
	182	&i2c_eeprom);
	183	if (ret) {
	184	debug("%s: could not get backing device\n", dev->name);
	185	return ret;
	186	}
	187
	188	ret = i2c_eeprom_read(i2c_eeprom, offset, &priv->val, 1);
	189	if (ret < 0) {
	190	debug("%s: read failed\n", __func__);
	191	return -EIO;
	192	}
	193
	194	sysinfo_rcar_parse(priv);
	195
	196	return 0;
	197	}
	198
	199	static const struct udevice_id sysinfo_rcar_ids[] = {
	200	{ .compatible = "renesas,rcar-sysinfo" },
	201	{ /* sentinel */ }
	202	};
	203
	204	U_BOOT_DRIVER(sysinfo_rcar) = {
	205	.name = "sysinfo_rcar",
	206	.id = UCLASS_SYSINFO,
	207	.of_match = sysinfo_rcar_ids,
	208	.ops = &sysinfo_rcar_ops,
	209	.priv_auto = sizeof(struct sysinfo_rcar_priv),
	210	.probe = sysinfo_rcar_probe,
	211	};