Release 4.11 drivers/base/regmap/regmap-mmio.c

/*
 * Register map access API - MMIO support
 *
 * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/clk.h>
#include <linux/err.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/regmap.h>
#include <linux/slab.h>

#include "internal.h"


struct regmap_mmio_context {
	
void __iomem *regs;
	
unsigned val_bytes;
	
struct clk *clk;

	
void (*reg_write)(struct regmap_mmio_context *ctx,
			  unsigned int reg, unsigned int val);
	
unsigned int (*reg_read)(struct regmap_mmio_context *ctx,
			         unsigned int reg);
};



static int regmap_mmio_regbits_check(size_t reg_bits)
{
	switch (reg_bits) {
	case 8:
	case 16:
	case 32:
#ifdef CONFIG_64BIT
	case 64:
#endif
		return 0;
	default:
		return -EINVAL;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Xiubo Li
40
100.00%
1
100.00%
Total
40
100.00%
1
100.00%



static int regmap_mmio_get_min_stride(size_t val_bits)
{
	int min_stride;

	switch (val_bits) {
	case 8:
		/* The core treats 0 as 1 */
		min_stride = 0;
		return 0;
	case 16:
		min_stride = 2;
		break;
	case 32:
		min_stride = 4;
		break;
#ifdef CONFIG_64BIT
	case 64:
		min_stride = 8;
		break;
#endif
	default:
		return -EINVAL;
	}

	return min_stride;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Xiubo Li
66
100.00%
1
100.00%
Total
66
100.00%
1
100.00%



static void regmap_mmio_write8(struct regmap_mmio_context *ctx,
				unsigned int reg,
				unsigned int val)
{
	writeb(val, ctx->regs + reg);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mark Brown
20
66.67%
1
33.33%
Xiubo Li
9
30.00%
1
33.33%
Philipp Zabel
1
3.33%
1
33.33%
Total
30
100.00%
3
100.00%



static void regmap_mmio_write16le(struct regmap_mmio_context *ctx,
				  unsigned int reg,
				  unsigned int val)
{
	writew(val, ctx->regs + reg);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mark Brown
20
66.67%
1
50.00%
Xiubo Li
10
33.33%
1
50.00%
Total
30
100.00%
2
100.00%



static void regmap_mmio_write16be(struct regmap_mmio_context *ctx,
				  unsigned int reg,
				  unsigned int val)
{
	iowrite16be(val, ctx->regs + reg);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mark Brown
14
46.67%
1
25.00%
Stephen Warren
8
26.67%
1
25.00%
Philipp Zabel
5
16.67%
1
25.00%
Xiubo Li
3
10.00%
1
25.00%
Total
30
100.00%
4
100.00%



static void regmap_mmio_write32le(struct regmap_mmio_context *ctx,
				  unsigned int reg,
				  unsigned int val)
{
	writel(val, ctx->regs + reg);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mark Brown
19
63.33%
1
50.00%
Stephen Warren
11
36.67%
1
50.00%
Total
30
100.00%
2
100.00%



static void regmap_mmio_write32be(struct regmap_mmio_context *ctx,
				  unsigned int reg,
				  unsigned int val)
{
	iowrite32be(val, ctx->regs + reg);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mark Brown
20
66.67%
1
50.00%
Stephen Warren
10
33.33%
1
50.00%
Total
30
100.00%
2
100.00%

#ifdef CONFIG_64BIT


static void regmap_mmio_write64le(struct regmap_mmio_context *ctx,
				  unsigned int reg,
				  unsigned int val)
{
	writeq(val, ctx->regs + reg);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Mark Brown
21
70.00%
1
50.00%
Stephen Warren
9
30.00%
1
50.00%
Total
30
100.00%
2
100.00%

#endif



static int regmap_mmio_write(void *context, unsigned int reg, unsigned int val)
{
	struct regmap_mmio_context *ctx = context;
	int ret;

	if (!IS_ERR(ctx->clk)) {
		ret = clk_enable(ctx->clk);
		if (ret < 0)
			return ret;
	}

	ctx->reg_write(ctx, reg, val);

	if (!IS_ERR(ctx->clk))
		clk_disable(ctx->clk);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mark Brown
60
67.42%
1
25.00%
Stephen Warren
16
17.98%
2
50.00%
Philipp Zabel
13
14.61%
1
25.00%
Total
89
100.00%
4
100.00%



static unsigned int regmap_mmio_read8(struct regmap_mmio_context *ctx,
				      unsigned int reg)
{
	return readb(ctx->regs + reg);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mark Brown
9
34.62%
1
25.00%
Stephen Warren
9
34.62%
1
25.00%
Xiubo Li
8
30.77%
2
50.00%
Total
26
100.00%
4
100.00%



static unsigned int regmap_mmio_read16le(struct regmap_mmio_context *ctx,
				         unsigned int reg)
{
	return readw(ctx->regs + reg);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mark Brown
18
69.23%
1
50.00%
Stephen Warren
8
30.77%
1
50.00%
Total
26
100.00%
2
100.00%



static unsigned int regmap_mmio_read16be(struct regmap_mmio_context *ctx,
				         unsigned int reg)
{
	return ioread16be(ctx->regs + reg);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mark Brown
16
61.54%
1
20.00%
Stephen Warren
6
23.08%
2
40.00%
Philipp Zabel
2
7.69%
1
20.00%
Xiubo Li
2
7.69%
1
20.00%
Total
26
100.00%
5
100.00%



static unsigned int regmap_mmio_read32le(struct regmap_mmio_context *ctx,
				         unsigned int reg)
{
	return readl(ctx->regs + reg);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mark Brown
19
73.08%
1
50.00%
Philipp Zabel
7
26.92%
1
50.00%
Total
26
100.00%
2
100.00%



static unsigned int regmap_mmio_read32be(struct regmap_mmio_context *ctx,
				         unsigned int reg)
{
	return ioread32be(ctx->regs + reg);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mark Brown
18
69.23%
1
50.00%
Stephen Warren
8
30.77%
1
50.00%
Total
26
100.00%
2
100.00%

#ifdef CONFIG_64BIT


static unsigned int regmap_mmio_read64le(struct regmap_mmio_context *ctx,
				         unsigned int reg)
{
	return readq(ctx->regs + reg);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Mark Brown
20
76.92%
1
50.00%
Stephen Warren
6
23.08%
1
50.00%
Total
26
100.00%
2
100.00%

#endif



static int regmap_mmio_read(void *context, unsigned int reg, unsigned int *val)
{
	struct regmap_mmio_context *ctx = context;
	int ret;

	if (!IS_ERR(ctx->clk)) {
		ret = clk_enable(ctx->clk);
		if (ret < 0)
			return ret;
	}

	*val = ctx->reg_read(ctx, reg);

	if (!IS_ERR(ctx->clk))
		clk_disable(ctx->clk);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mark Brown
53
58.24%
1
25.00%
Stephen Warren
25
27.47%
2
50.00%
Philipp Zabel
13
14.29%
1
25.00%
Total
91
100.00%
4
100.00%



static void regmap_mmio_free_context(void *context)
{
	struct regmap_mmio_context *ctx = context;

	if (!IS_ERR(ctx->clk)) {
		clk_unprepare(ctx->clk);
		clk_put(ctx->clk);
	}
	kfree(context);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Philipp Zabel
29
60.42%
1
33.33%
Stephen Warren
19
39.58%
2
66.67%
Total
48
100.00%
3
100.00%


static const struct regmap_bus regmap_mmio = {
	.fast_io = true,
	.reg_write = regmap_mmio_write,
	.reg_read = regmap_mmio_read,
	.free_context = regmap_mmio_free_context,
	.val_format_endian_default = REGMAP_ENDIAN_LITTLE,
};



static struct regmap_mmio_context *regmap_mmio_gen_context(struct device *dev,
					const char *clk_id,
					void __iomem *regs,
					const struct regmap_config *config)
{
	struct regmap_mmio_context *ctx;
	int min_stride;
	int ret;

	ret = regmap_mmio_regbits_check(config->reg_bits);
	if (ret)
		return ERR_PTR(ret);

	if (config->pad_bits)
		return ERR_PTR(-EINVAL);

	min_stride = regmap_mmio_get_min_stride(config->val_bits);
	if (min_stride < 0)
		return ERR_PTR(min_stride);

	if (config->reg_stride < min_stride)
		return ERR_PTR(-EINVAL);

	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
	if (!ctx)
		return ERR_PTR(-ENOMEM);

	ctx->regs = regs;
	ctx->val_bytes = config->val_bits / 8;
	ctx->clk = ERR_PTR(-ENODEV);

	switch (regmap_get_val_endian(dev, &regmap_mmio, config)) {
	case REGMAP_ENDIAN_DEFAULT:
	case REGMAP_ENDIAN_LITTLE:
#ifdef __LITTLE_ENDIAN
	case REGMAP_ENDIAN_NATIVE:
#endif
		switch (config->val_bits) {
		case 8:
			ctx->reg_read = regmap_mmio_read8;
			ctx->reg_write = regmap_mmio_write8;
			break;
		case 16:
			ctx->reg_read = regmap_mmio_read16le;
			ctx->reg_write = regmap_mmio_write16le;
			break;
		case 32:
			ctx->reg_read = regmap_mmio_read32le;
			ctx->reg_write = regmap_mmio_write32le;
			break;
#ifdef CONFIG_64BIT
		case 64:
			ctx->reg_read = regmap_mmio_read64le;
			ctx->reg_write = regmap_mmio_write64le;
			break;
#endif
		default:
			ret = -EINVAL;
			goto err_free;
		}
		break;
	case REGMAP_ENDIAN_BIG:
#ifdef __BIG_ENDIAN
	case REGMAP_ENDIAN_NATIVE:
#endif
		switch (config->val_bits) {
		case 8:
			ctx->reg_read = regmap_mmio_read8;
			ctx->reg_write = regmap_mmio_write8;
			break;
		case 16:
			ctx->reg_read = regmap_mmio_read16be;
			ctx->reg_write = regmap_mmio_write16be;
			break;
		case 32:
			ctx->reg_read = regmap_mmio_read32be;
			ctx->reg_write = regmap_mmio_write32be;
			break;
		default:
			ret = -EINVAL;
			goto err_free;
		}
		break;
	default:
		ret = -EINVAL;
		goto err_free;
	}

	if (clk_id == NULL)
		return ctx;

	ctx->clk = clk_get(dev, clk_id);
	if (IS_ERR(ctx->clk)) {
		ret = PTR_ERR(ctx->clk);
		goto err_free;
	}

	ret = clk_prepare(ctx->clk);
	if (ret < 0) {
		clk_put(ctx->clk);
		goto err_free;
	}

	return ctx;

err_free:
	kfree(ctx);

	return ERR_PTR(ret);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mark Brown
193
43.27%
2
18.18%
Stephen Warren
120
26.91%
3
27.27%
Philipp Zabel
96
21.52%
1
9.09%
Xiubo Li
34
7.62%
3
27.27%
Dimitris Papastamos
2
0.45%
1
9.09%
Axel Lin
1
0.22%
1
9.09%
Total
446
100.00%
11
100.00%



struct regmap *__regmap_init_mmio_clk(struct device *dev, const char *clk_id,
				      void __iomem *regs,
				      const struct regmap_config *config,
				      struct lock_class_key *lock_key,
				      const char *lock_name)
{
	struct regmap_mmio_context *ctx;

	ctx = regmap_mmio_gen_context(dev, clk_id, regs, config);
	if (IS_ERR(ctx))
		return ERR_CAST(ctx);

	return __regmap_init(dev, &regmap_mmio, ctx, config,
			     lock_key, lock_name);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Stephen Warren
61
70.93%
1
33.33%
Nicolas Boichat
16
18.60%
1
33.33%
Philipp Zabel
9
10.47%
1
33.33%
Total
86
100.00%
3
100.00%


EXPORT_SYMBOL_GPL(__regmap_init_mmio_clk);



struct regmap *__devm_regmap_init_mmio_clk(struct device *dev,
					   const char *clk_id,
					   void __iomem *regs,
					   const struct regmap_config *config,
					   struct lock_class_key *lock_key,
					   const char *lock_name)
{
	struct regmap_mmio_context *ctx;

	ctx = regmap_mmio_gen_context(dev, clk_id, regs, config);
	if (IS_ERR(ctx))
		return ERR_CAST(ctx);

	return __devm_regmap_init(dev, &regmap_mmio, ctx, config,
				  lock_key, lock_name);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Stephen Warren
61
70.93%
1
33.33%
Nicolas Boichat
16
18.60%
1
33.33%
Philipp Zabel
9
10.47%
1
33.33%
Total
86
100.00%
3
100.00%


EXPORT_SYMBOL_GPL(__devm_regmap_init_mmio_clk);

MODULE_LICENSE("GPL v2");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Mark Brown
571
40.13%
3
18.75%
Stephen Warren
447
31.41%
3
18.75%
Philipp Zabel
192
13.49%
2
12.50%
Xiubo Li
176
12.37%
5
31.25%
Nicolas Boichat
34
2.39%
1
6.25%
Dimitris Papastamos
2
0.14%
1
6.25%
Axel Lin
1
0.07%
1
6.25%
Total
1423
100.00%
16
100.00%
Directory: drivers/base/regmap

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.