[people/ms/u-boot.git] / drivers / core / syscon-uclass.c

/*
 * Copyright (C) 2015 Google, Inc
 * Written by Simon Glass <sjg@chromium.org>
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <syscon.h>
#include <dm.h>
#include <errno.h>
#include <regmap.h>
#include <dm/device-internal.h>
#include <dm/lists.h>
#include <dm/root.h>
#include <linux/err.h>

struct regmap *syscon_get_regmap(struct udevice *dev)
{
	struct syscon_uc_info *priv;

	if (device_get_uclass_id(dev) != UCLASS_SYSCON)
		return ERR_PTR(-ENOEXEC);
	priv = dev_get_uclass_priv(dev);
	return priv->regmap;
}

static int syscon_pre_probe(struct udevice *dev)
{
	struct syscon_uc_info *priv = dev_get_uclass_priv(dev);

	/*
	 * With OF_PLATDATA we really have no way of knowing the format of
	 * the device-specific platform data. So we assume that it starts with
	 * a 'reg' member, and this holds a single address and size. Drivers
	 * using OF_PLATDATA will need to ensure that this is true.
	 */
#if CONFIG_IS_ENABLED(OF_PLATDATA)
	struct syscon_base_platdata *plat = dev_get_platdata(dev);

	return regmap_init_mem_platdata(dev, plat->reg, ARRAY_SIZE(plat->reg),
					&priv->regmap);
#else
	return regmap_init_mem(dev, &priv->regmap);
#endif
}

int syscon_get_by_driver_data(ulong driver_data, struct udevice **devp)
{
	struct udevice *dev;
	struct uclass *uc;
	int ret;

	*devp = NULL;
	ret = uclass_get(UCLASS_SYSCON, &uc);
	if (ret)
		return ret;
	uclass_foreach_dev(dev, uc) {
		if (dev->driver_data == driver_data) {
			*devp = dev;
			return device_probe(dev);
		}
	}

	return -ENODEV;
}

struct regmap *syscon_get_regmap_by_driver_data(ulong driver_data)
{
	struct syscon_uc_info *priv;
	struct udevice *dev;
	int ret;

	ret = syscon_get_by_driver_data(driver_data, &dev);
	if (ret)
		return ERR_PTR(ret);
	priv = dev_get_uclass_priv(dev);

	return priv->regmap;
}

void *syscon_get_first_range(ulong driver_data)
{
	struct regmap *map;

	map = syscon_get_regmap_by_driver_data(driver_data);
	if (IS_ERR(map))
		return map;
	return regmap_get_range(map, 0);
}

UCLASS_DRIVER(syscon) = {
	.id		= UCLASS_SYSCON,
	.name		= "syscon",
	.per_device_auto_alloc_size = sizeof(struct syscon_uc_info),
	.pre_probe = syscon_pre_probe,
};

static const struct udevice_id generic_syscon_ids[] = {
	{ .compatible = "syscon" },
	{ }
};

U_BOOT_DRIVER(generic_syscon) = {
	.name	= "syscon",
	.id	= UCLASS_SYSCON,
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
	.bind           = dm_scan_fdt_dev,
#endif
	.of_match = generic_syscon_ids,
};
Commit	Line	Data
57251285 SG	1	/*
	2	* Copyright (C) 2015 Google, Inc
	3	* Written by Simon Glass <sjg@chromium.org>
	4	*
	5	* SPDX-License-Identifier: GPL-2.0+
	6	*/
	7
	8	#include <common.h>
	9	#include <syscon.h>
	10	#include <dm.h>
	11	#include <errno.h>
	12	#include <regmap.h>
	13	#include <dm/device-internal.h>
	14	#include <dm/lists.h>
	15	#include <dm/root.h>
	16	#include <linux/err.h>
	17
	18	struct regmap syscon_get_regmap(struct udevice dev)
	19	{
9f4629be	20	struct syscon_uc_info *priv;
57251285	21
9f4629be SG	22	if (device_get_uclass_id(dev) != UCLASS_SYSCON)
	23	return ERR_PTR(-ENOEXEC);
	24	priv = dev_get_uclass_priv(dev);
57251285 SG	25	return priv->regmap;
	26	}
	27
	28	static int syscon_pre_probe(struct udevice *dev)
	29	{
	30	struct syscon_uc_info *priv = dev_get_uclass_priv(dev);
	31
04ecf36b SG	32	/*
	33	* With OF_PLATDATA we really have no way of knowing the format of
	34	* the device-specific platform data. So we assume that it starts with
	35	* a 'reg' member, and this holds a single address and size. Drivers
	36	* using OF_PLATDATA will need to ensure that this is true.
	37	*/
	38	#if CONFIG_IS_ENABLED(OF_PLATDATA)
	39	struct syscon_base_platdata *plat = dev_get_platdata(dev);
	40
	41	return regmap_init_mem_platdata(dev, plat->reg, ARRAY_SIZE(plat->reg),
	42	&priv->regmap);
	43	#else
57251285	44	return regmap_init_mem(dev, &priv->regmap);
04ecf36b	45	#endif
57251285 SG	46	}
57251285 SG	47
ac94b7bc	48	int syscon_get_by_driver_data(ulong driver_data, struct udevice **devp)
57251285 SG	49	{
	50	struct udevice *dev;
	51	struct uclass *uc;
	52	int ret;
	53
532f2435	54	*devp = NULL;
57251285 SG	55	ret = uclass_get(UCLASS_SYSCON, &uc);
57251285 SG	56	if (ret)
ac94b7bc	57	return ret;
57251285 SG	58	uclass_foreach_dev(dev, uc) {
57251285 SG	59	if (dev->driver_data == driver_data) {
ac94b7bc SG	60	*devp = dev;
ac94b7bc SG	61	return device_probe(dev);
57251285 SG	62	}
	63	}
	64
ac94b7bc SG	65	return -ENODEV;
	66	}
	67
	68	struct regmap *syscon_get_regmap_by_driver_data(ulong driver_data)
	69	{
	70	struct syscon_uc_info *priv;
	71	struct udevice *dev;
	72	int ret;
	73
	74	ret = syscon_get_by_driver_data(driver_data, &dev);
	75	if (ret)
	76	return ERR_PTR(ret);
	77	priv = dev_get_uclass_priv(dev);
	78
	79	return priv->regmap;
57251285 SG	80	}
	81
	82	void *syscon_get_first_range(ulong driver_data)
	83	{
	84	struct regmap *map;
	85
	86	map = syscon_get_regmap_by_driver_data(driver_data);
	87	if (IS_ERR(map))
	88	return map;
	89	return regmap_get_range(map, 0);
	90	}
	91
	92	UCLASS_DRIVER(syscon) = {
	93	.id = UCLASS_SYSCON,
	94	.name = "syscon",
	95	.per_device_auto_alloc_size = sizeof(struct syscon_uc_info),
	96	.pre_probe = syscon_pre_probe,
	97	};
8291bc87 PB	98
	99	static const struct udevice_id generic_syscon_ids[] = {
	100	{ .compatible = "syscon" },
	101	{ }
	102	};
	103
	104	U_BOOT_DRIVER(generic_syscon) = {
	105	.name = "syscon",
	106	.id = UCLASS_SYSCON,
745fb9c2 SG	107	#if !CONFIG_IS_ENABLED(OF_PLATDATA)
	108	.bind = dm_scan_fdt_dev,
	109	#endif
8291bc87 PB	110	.of_match = generic_syscon_ids,
8291bc87 PB	111	};