[linux-block.git] / drivers / nvmem / imx-iim.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * i.MX IIM driver
 *
 * Copyright (c) 2017 Pengutronix, Michael Grzeschik <m.grzeschik@pengutronix.de>
 *
 * Based on the barebox iim driver,
 * Copyright (c) 2010 Baruch Siach <baruch@tkos.co.il>,
 *	Orex Computed Radiography
 */

#include <linux/device.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/nvmem-provider.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/clk.h>

#define IIM_BANK_BASE(n)	(0x800 + 0x400 * (n))

struct imx_iim_drvdata {
	unsigned int nregs;
};

struct iim_priv {
	void __iomem *base;
	struct clk *clk;
};

static int imx_iim_read(void *context, unsigned int offset,
			  void *buf, size_t bytes)
{
	struct iim_priv *iim = context;
	int i, ret;
	u8 *buf8 = buf;

	ret = clk_prepare_enable(iim->clk);
	if (ret)
		return ret;

	for (i = offset; i < offset + bytes; i++) {
		int bank = i >> 5;
		int reg = i & 0x1f;

		*buf8++ = readl(iim->base + IIM_BANK_BASE(bank) + reg * 4);
	}

	clk_disable_unprepare(iim->clk);

	return 0;
}

static struct imx_iim_drvdata imx27_drvdata = {
	.nregs = 2 * 32,
};

static struct imx_iim_drvdata imx25_imx31_imx35_drvdata = {
	.nregs = 3 * 32,
};

static struct imx_iim_drvdata imx51_drvdata = {
	.nregs = 4 * 32,
};

static struct imx_iim_drvdata imx53_drvdata = {
	.nregs = 4 * 32 + 16,
};

static const struct of_device_id imx_iim_dt_ids[] = {
	{
		.compatible = "fsl,imx25-iim",
		.data = &imx25_imx31_imx35_drvdata,
	}, {
		.compatible = "fsl,imx27-iim",
		.data = &imx27_drvdata,
	}, {
		.compatible = "fsl,imx31-iim",
		.data = &imx25_imx31_imx35_drvdata,
	}, {
		.compatible = "fsl,imx35-iim",
		.data = &imx25_imx31_imx35_drvdata,
	}, {
		.compatible = "fsl,imx51-iim",
		.data = &imx51_drvdata,
	}, {
		.compatible = "fsl,imx53-iim",
		.data = &imx53_drvdata,
	}, {
		/* sentinel */
	},
};
MODULE_DEVICE_TABLE(of, imx_iim_dt_ids);

static int imx_iim_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct iim_priv *iim;
	struct nvmem_device *nvmem;
	struct nvmem_config cfg = {};
	const struct imx_iim_drvdata *drvdata = NULL;

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

	iim->base = devm_platform_ioremap_resource(pdev, 0);
	if (IS_ERR(iim->base))
		return PTR_ERR(iim->base);

	drvdata = of_device_get_match_data(&pdev->dev);

	iim->clk = devm_clk_get(dev, NULL);
	if (IS_ERR(iim->clk))
		return PTR_ERR(iim->clk);

	cfg.name = "imx-iim",
	cfg.read_only = true,
	cfg.word_size = 1,
	cfg.stride = 1,
	cfg.reg_read = imx_iim_read,
	cfg.dev = dev;
	cfg.size = drvdata->nregs;
	cfg.priv = iim;

	nvmem = devm_nvmem_register(dev, &cfg);

	return PTR_ERR_OR_ZERO(nvmem);
}

static struct platform_driver imx_iim_driver = {
	.probe	= imx_iim_probe,
	.driver = {
		.name	= "imx-iim",
		.of_match_table = imx_iim_dt_ids,
	},
};
module_platform_driver(imx_iim_driver);

MODULE_AUTHOR("Michael Grzeschik <m.grzeschik@pengutronix.de>");
MODULE_DESCRIPTION("i.MX IIM driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
acee2e8d	1	// SPDX-License-Identifier: GPL-2.0-only
c066c1c0 MG	2	/*
	3	* i.MX IIM driver
	4	*
	5	* Copyright (c) 2017 Pengutronix, Michael Grzeschik <m.grzeschik@pengutronix.de>
	6	*
	7	* Based on the barebox iim driver,
	8	* Copyright (c) 2010 Baruch Siach <baruch@tkos.co.il>,
	9	* Orex Computed Radiography
c066c1c0 MG	10	*/
	11
	12	#include <linux/device.h>
	13	#include <linux/io.h>
	14	#include <linux/module.h>
	15	#include <linux/nvmem-provider.h>
	16	#include <linux/of.h>
	17	#include <linux/of_device.h>
	18	#include <linux/platform_device.h>
	19	#include <linux/slab.h>
	20	#include <linux/clk.h>
	21
	22	#define IIM_BANK_BASE(n) (0x800 + 0x400 * (n))
	23
	24	struct imx_iim_drvdata {
	25	unsigned int nregs;
	26	};
	27
	28	struct iim_priv {
	29	void __iomem *base;
	30	struct clk *clk;
c066c1c0 MG	31	};
	32
	33	static int imx_iim_read(void *context, unsigned int offset,
	34	void *buf, size_t bytes)
	35	{
	36	struct iim_priv *iim = context;
	37	int i, ret;
	38	u8 *buf8 = buf;
	39
	40	ret = clk_prepare_enable(iim->clk);
	41	if (ret)
	42	return ret;
	43
	44	for (i = offset; i < offset + bytes; i++) {
	45	int bank = i >> 5;
	46	int reg = i & 0x1f;
	47
	48	buf8++ = readl(iim->base + IIM_BANK_BASE(bank) + reg 4);
	49	}
	50
	51	clk_disable_unprepare(iim->clk);
	52
	53	return 0;
	54	}
	55
	56	static struct imx_iim_drvdata imx27_drvdata = {
	57	.nregs = 2 * 32,
	58	};
	59
	60	static struct imx_iim_drvdata imx25_imx31_imx35_drvdata = {
	61	.nregs = 3 * 32,
	62	};
	63
	64	static struct imx_iim_drvdata imx51_drvdata = {
	65	.nregs = 4 * 32,
	66	};
	67
	68	static struct imx_iim_drvdata imx53_drvdata = {
	69	.nregs = 4 * 32 + 16,
	70	};
	71
	72	static const struct of_device_id imx_iim_dt_ids[] = {
	73	{
	74	.compatible = "fsl,imx25-iim",
	75	.data = &imx25_imx31_imx35_drvdata,
	76	}, {
	77	.compatible = "fsl,imx27-iim",
	78	.data = &imx27_drvdata,
	79	}, {
	80	.compatible = "fsl,imx31-iim",
	81	.data = &imx25_imx31_imx35_drvdata,
	82	}, {
	83	.compatible = "fsl,imx35-iim",
	84	.data = &imx25_imx31_imx35_drvdata,
	85	}, {
	86	.compatible = "fsl,imx51-iim",
	87	.data = &imx51_drvdata,
	88	}, {
	89	.compatible = "fsl,imx53-iim",
	90	.data = &imx53_drvdata,
	91	}, {
	92	/* sentinel */
	93	},
	94	};
95	MODULE_DEVICE_TABLE(of, imx_iim_dt_ids);
96
97	static int imx_iim_probe(struct platform_device *pdev)
98	{
c066c1c0	99	struct device *dev = &pdev->dev;
c066c1c0 MG	100	struct iim_priv *iim;
c066c1c0 MG	101	struct nvmem_device *nvmem;
01d35cab	102	struct nvmem_config cfg = {};
c066c1c0 MG	103	const struct imx_iim_drvdata *drvdata = NULL;
	104
	105	iim = devm_kzalloc(dev, sizeof(*iim), GFP_KERNEL);
	106	if (!iim)
	107	return -ENOMEM;
	108
ededa045	109	iim->base = devm_platform_ioremap_resource(pdev, 0);
c066c1c0 MG	110	if (IS_ERR(iim->base))
	111	return PTR_ERR(iim->base);
	112
579db09c	113	drvdata = of_device_get_match_data(&pdev->dev);
c066c1c0	114
b28b7381	115	iim->clk = devm_clk_get(dev, NULL);
c066c1c0 MG	116	if (IS_ERR(iim->clk))
	117	return PTR_ERR(iim->clk);
	118
01d35cab MY	119	cfg.name = "imx-iim",
	120	cfg.read_only = true,
	121	cfg.word_size = 1,
	122	cfg.stride = 1,
01d35cab MY	123	cfg.reg_read = imx_iim_read,
	124	cfg.dev = dev;
	125	cfg.size = drvdata->nregs;
	126	cfg.priv = iim;
	127
547a2c9b	128	nvmem = devm_nvmem_register(dev, &cfg);
c066c1c0	129
547a2c9b	130	return PTR_ERR_OR_ZERO(nvmem);
c066c1c0 MG	131	}
	132
	133	static struct platform_driver imx_iim_driver = {
	134	.probe = imx_iim_probe,
c066c1c0 MG	135	.driver = {
	136	.name = "imx-iim",
	137	.of_match_table = imx_iim_dt_ids,
	138	},
	139	};
	140	module_platform_driver(imx_iim_driver);
	141
	142	MODULE_AUTHOR("Michael Grzeschik <m.grzeschik@pengutronix.de>");
	143	MODULE_DESCRIPTION("i.MX IIM driver");
	144	MODULE_LICENSE("GPL v2");