2012-04-04 21:48:31 +00:00
|
|
|
/*
|
|
|
|
* 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/>.
|
|
|
|
*/
|
|
|
|
|
2013-02-14 16:39:08 +00:00
|
|
|
#include <linux/clk.h>
|
2012-04-04 21:48:31 +00:00
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/io.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/regmap.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
|
|
|
|
struct regmap_mmio_context {
|
|
|
|
void __iomem *regs;
|
2014-03-27 04:42:43 +00:00
|
|
|
unsigned reg_bytes;
|
2012-04-04 21:48:31 +00:00
|
|
|
unsigned val_bytes;
|
2014-03-27 04:42:43 +00:00
|
|
|
unsigned pad_bytes;
|
2013-02-14 16:39:08 +00:00
|
|
|
struct clk *clk;
|
2012-04-04 21:48:31 +00:00
|
|
|
};
|
|
|
|
|
2014-03-27 04:42:42 +00:00
|
|
|
static inline void regmap_mmio_regsize_check(size_t reg_size)
|
|
|
|
{
|
2014-03-27 04:42:43 +00:00
|
|
|
switch (reg_size) {
|
|
|
|
case 1:
|
|
|
|
case 2:
|
|
|
|
case 4:
|
|
|
|
#ifdef CONFIG_64BIT
|
|
|
|
case 8:
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
2014-03-27 04:42:42 +00:00
|
|
|
}
|
|
|
|
|
2014-03-28 05:12:56 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-16 14:25:34 +00:00
|
|
|
static inline void regmap_mmio_count_check(size_t count, u32 offset)
|
2014-03-27 04:42:42 +00:00
|
|
|
{
|
2014-05-16 14:25:34 +00:00
|
|
|
BUG_ON(count <= offset);
|
2014-03-27 04:42:42 +00:00
|
|
|
}
|
|
|
|
|
2014-04-02 02:20:17 +00:00
|
|
|
static inline unsigned int
|
|
|
|
regmap_mmio_get_offset(const void *reg, size_t reg_size)
|
|
|
|
{
|
|
|
|
switch (reg_size) {
|
|
|
|
case 1:
|
|
|
|
return *(u8 *)reg;
|
|
|
|
case 2:
|
|
|
|
return *(u16 *)reg;
|
|
|
|
case 4:
|
|
|
|
return *(u32 *)reg;
|
|
|
|
#ifdef CONFIG_64BIT
|
|
|
|
case 8:
|
|
|
|
return *(u64 *)reg;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
2014-03-27 04:42:42 +00:00
|
|
|
}
|
|
|
|
|
2012-04-04 21:48:31 +00:00
|
|
|
static int regmap_mmio_gather_write(void *context,
|
|
|
|
const void *reg, size_t reg_size,
|
|
|
|
const void *val, size_t val_size)
|
|
|
|
{
|
|
|
|
struct regmap_mmio_context *ctx = context;
|
2014-04-02 02:20:17 +00:00
|
|
|
unsigned int offset;
|
2013-02-14 16:39:08 +00:00
|
|
|
int ret;
|
2012-04-04 21:48:31 +00:00
|
|
|
|
2014-03-27 04:42:42 +00:00
|
|
|
regmap_mmio_regsize_check(reg_size);
|
2012-04-06 21:17:32 +00:00
|
|
|
|
2013-11-25 22:12:47 +00:00
|
|
|
if (!IS_ERR(ctx->clk)) {
|
2013-02-14 16:39:08 +00:00
|
|
|
ret = clk_enable(ctx->clk);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-04-02 02:20:17 +00:00
|
|
|
offset = regmap_mmio_get_offset(reg, reg_size);
|
2012-04-04 21:48:31 +00:00
|
|
|
|
|
|
|
while (val_size) {
|
|
|
|
switch (ctx->val_bytes) {
|
|
|
|
case 1:
|
|
|
|
writeb(*(u8 *)val, ctx->regs + offset);
|
|
|
|
break;
|
|
|
|
case 2:
|
2012-05-24 16:47:27 +00:00
|
|
|
writew(*(u16 *)val, ctx->regs + offset);
|
2012-04-04 21:48:31 +00:00
|
|
|
break;
|
|
|
|
case 4:
|
2012-05-24 16:47:27 +00:00
|
|
|
writel(*(u32 *)val, ctx->regs + offset);
|
2012-04-04 21:48:31 +00:00
|
|
|
break;
|
|
|
|
#ifdef CONFIG_64BIT
|
|
|
|
case 8:
|
2012-05-24 16:47:27 +00:00
|
|
|
writeq(*(u64 *)val, ctx->regs + offset);
|
2012-04-04 21:48:31 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
/* Should be caught by regmap_mmio_check_config */
|
2012-04-06 21:17:32 +00:00
|
|
|
BUG();
|
2012-04-04 21:48:31 +00:00
|
|
|
}
|
|
|
|
val_size -= ctx->val_bytes;
|
|
|
|
val += ctx->val_bytes;
|
|
|
|
offset += ctx->val_bytes;
|
|
|
|
}
|
|
|
|
|
2013-11-25 22:12:47 +00:00
|
|
|
if (!IS_ERR(ctx->clk))
|
2013-02-14 16:39:08 +00:00
|
|
|
clk_disable(ctx->clk);
|
|
|
|
|
2012-04-04 21:48:31 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int regmap_mmio_write(void *context, const void *data, size_t count)
|
|
|
|
{
|
2014-03-27 04:42:43 +00:00
|
|
|
struct regmap_mmio_context *ctx = context;
|
2014-04-02 02:20:17 +00:00
|
|
|
unsigned int offset = ctx->reg_bytes + ctx->pad_bytes;
|
2014-03-27 04:42:43 +00:00
|
|
|
|
2014-05-16 14:25:34 +00:00
|
|
|
regmap_mmio_count_check(count, offset);
|
2012-04-06 21:17:32 +00:00
|
|
|
|
2014-03-27 04:42:43 +00:00
|
|
|
return regmap_mmio_gather_write(context, data, ctx->reg_bytes,
|
|
|
|
data + offset, count - offset);
|
2012-04-04 21:48:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int regmap_mmio_read(void *context,
|
|
|
|
const void *reg, size_t reg_size,
|
|
|
|
void *val, size_t val_size)
|
|
|
|
{
|
|
|
|
struct regmap_mmio_context *ctx = context;
|
2014-04-02 02:20:17 +00:00
|
|
|
unsigned int offset;
|
2013-02-14 16:39:08 +00:00
|
|
|
int ret;
|
2012-04-04 21:48:31 +00:00
|
|
|
|
2014-03-27 04:42:42 +00:00
|
|
|
regmap_mmio_regsize_check(reg_size);
|
2012-04-06 21:17:32 +00:00
|
|
|
|
2013-11-25 22:12:47 +00:00
|
|
|
if (!IS_ERR(ctx->clk)) {
|
2013-02-14 16:39:08 +00:00
|
|
|
ret = clk_enable(ctx->clk);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-04-02 02:20:17 +00:00
|
|
|
offset = regmap_mmio_get_offset(reg, reg_size);
|
2012-04-04 21:48:31 +00:00
|
|
|
|
|
|
|
while (val_size) {
|
|
|
|
switch (ctx->val_bytes) {
|
|
|
|
case 1:
|
|
|
|
*(u8 *)val = readb(ctx->regs + offset);
|
|
|
|
break;
|
|
|
|
case 2:
|
2012-05-24 16:47:27 +00:00
|
|
|
*(u16 *)val = readw(ctx->regs + offset);
|
2012-04-04 21:48:31 +00:00
|
|
|
break;
|
|
|
|
case 4:
|
2012-05-24 16:47:27 +00:00
|
|
|
*(u32 *)val = readl(ctx->regs + offset);
|
2012-04-04 21:48:31 +00:00
|
|
|
break;
|
|
|
|
#ifdef CONFIG_64BIT
|
|
|
|
case 8:
|
2012-05-24 16:47:27 +00:00
|
|
|
*(u64 *)val = readq(ctx->regs + offset);
|
2012-04-04 21:48:31 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
/* Should be caught by regmap_mmio_check_config */
|
2012-04-06 21:17:32 +00:00
|
|
|
BUG();
|
2012-04-04 21:48:31 +00:00
|
|
|
}
|
|
|
|
val_size -= ctx->val_bytes;
|
|
|
|
val += ctx->val_bytes;
|
|
|
|
offset += ctx->val_bytes;
|
|
|
|
}
|
|
|
|
|
2013-11-25 22:12:47 +00:00
|
|
|
if (!IS_ERR(ctx->clk))
|
2013-02-14 16:39:08 +00:00
|
|
|
clk_disable(ctx->clk);
|
|
|
|
|
2012-04-04 21:48:31 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void regmap_mmio_free_context(void *context)
|
|
|
|
{
|
2013-02-14 16:39:08 +00:00
|
|
|
struct regmap_mmio_context *ctx = context;
|
|
|
|
|
2013-11-25 22:12:47 +00:00
|
|
|
if (!IS_ERR(ctx->clk)) {
|
2013-02-14 16:39:08 +00:00
|
|
|
clk_unprepare(ctx->clk);
|
|
|
|
clk_put(ctx->clk);
|
|
|
|
}
|
2012-04-04 21:48:31 +00:00
|
|
|
kfree(context);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct regmap_bus regmap_mmio = {
|
|
|
|
.fast_io = true,
|
|
|
|
.write = regmap_mmio_write,
|
|
|
|
.gather_write = regmap_mmio_gather_write,
|
|
|
|
.read = regmap_mmio_read,
|
|
|
|
.free_context = regmap_mmio_free_context,
|
2012-05-24 16:47:27 +00:00
|
|
|
.reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
|
|
|
|
.val_format_endian_default = REGMAP_ENDIAN_NATIVE,
|
2012-04-04 21:48:31 +00:00
|
|
|
};
|
|
|
|
|
2013-02-14 16:39:08 +00:00
|
|
|
static struct regmap_mmio_context *regmap_mmio_gen_context(struct device *dev,
|
|
|
|
const char *clk_id,
|
|
|
|
void __iomem *regs,
|
2012-04-04 21:48:31 +00:00
|
|
|
const struct regmap_config *config)
|
|
|
|
{
|
|
|
|
struct regmap_mmio_context *ctx;
|
2012-04-09 19:40:24 +00:00
|
|
|
int min_stride;
|
2013-02-14 16:39:08 +00:00
|
|
|
int ret;
|
2012-04-04 21:48:31 +00:00
|
|
|
|
2014-03-28 05:12:56 +00:00
|
|
|
ret = regmap_mmio_regbits_check(config->reg_bits);
|
|
|
|
if (ret)
|
|
|
|
return ERR_PTR(ret);
|
2012-04-04 21:48:31 +00:00
|
|
|
|
|
|
|
if (config->pad_bits)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
|
|
|
switch (config->val_bits) {
|
|
|
|
case 8:
|
2012-04-09 19:40:24 +00:00
|
|
|
/* The core treats 0 as 1 */
|
|
|
|
min_stride = 0;
|
|
|
|
break;
|
2012-04-04 21:48:31 +00:00
|
|
|
case 16:
|
2012-04-09 19:40:24 +00:00
|
|
|
min_stride = 2;
|
|
|
|
break;
|
2012-04-04 21:48:31 +00:00
|
|
|
case 32:
|
2012-04-09 19:40:24 +00:00
|
|
|
min_stride = 4;
|
|
|
|
break;
|
2012-04-04 21:48:31 +00:00
|
|
|
#ifdef CONFIG_64BIT
|
|
|
|
case 64:
|
2012-04-09 19:40:24 +00:00
|
|
|
min_stride = 8;
|
|
|
|
break;
|
2012-04-04 21:48:31 +00:00
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
}
|
|
|
|
|
2012-04-09 19:40:24 +00:00
|
|
|
if (config->reg_stride < min_stride)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
2012-05-24 16:47:27 +00:00
|
|
|
switch (config->reg_format_endian) {
|
|
|
|
case REGMAP_ENDIAN_DEFAULT:
|
|
|
|
case REGMAP_ENDIAN_NATIVE:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
}
|
|
|
|
|
2012-07-18 13:17:23 +00:00
|
|
|
ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
|
2012-04-04 21:48:31 +00:00
|
|
|
if (!ctx)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
ctx->regs = regs;
|
|
|
|
ctx->val_bytes = config->val_bits / 8;
|
2014-03-27 04:42:43 +00:00
|
|
|
ctx->reg_bytes = config->reg_bits / 8;
|
|
|
|
ctx->pad_bytes = config->pad_bits / 8;
|
2013-11-25 22:12:47 +00:00
|
|
|
ctx->clk = ERR_PTR(-ENODEV);
|
2012-04-04 21:48:31 +00:00
|
|
|
|
2013-02-14 16:39:08 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-04-04 21:48:31 +00:00
|
|
|
return ctx;
|
2013-02-14 16:39:08 +00:00
|
|
|
|
|
|
|
err_free:
|
|
|
|
kfree(ctx);
|
|
|
|
|
|
|
|
return ERR_PTR(ret);
|
2012-04-04 21:48:31 +00:00
|
|
|
}
|
|
|
|
|
2015-07-08 06:30:18 +00: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)
|
2012-04-04 21:48:31 +00:00
|
|
|
{
|
|
|
|
struct regmap_mmio_context *ctx;
|
|
|
|
|
2013-02-14 16:39:08 +00:00
|
|
|
ctx = regmap_mmio_gen_context(dev, clk_id, regs, config);
|
2012-04-04 21:48:31 +00:00
|
|
|
if (IS_ERR(ctx))
|
|
|
|
return ERR_CAST(ctx);
|
|
|
|
|
2015-07-08 06:30:18 +00:00
|
|
|
return __regmap_init(dev, ®map_mmio, ctx, config,
|
|
|
|
lock_key, lock_name);
|
2012-04-04 21:48:31 +00:00
|
|
|
}
|
2015-07-08 06:30:18 +00:00
|
|
|
EXPORT_SYMBOL_GPL(__regmap_init_mmio_clk);
|
2012-04-04 21:48:31 +00:00
|
|
|
|
2015-07-08 06:30:18 +00:00
|
|
|
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)
|
2012-04-04 21:48:31 +00:00
|
|
|
{
|
|
|
|
struct regmap_mmio_context *ctx;
|
|
|
|
|
2013-02-14 16:39:08 +00:00
|
|
|
ctx = regmap_mmio_gen_context(dev, clk_id, regs, config);
|
2012-04-04 21:48:31 +00:00
|
|
|
if (IS_ERR(ctx))
|
|
|
|
return ERR_CAST(ctx);
|
|
|
|
|
2015-07-08 06:30:18 +00:00
|
|
|
return __devm_regmap_init(dev, ®map_mmio, ctx, config,
|
|
|
|
lock_key, lock_name);
|
2012-04-04 21:48:31 +00:00
|
|
|
}
|
2015-07-08 06:30:18 +00:00
|
|
|
EXPORT_SYMBOL_GPL(__devm_regmap_init_mmio_clk);
|
2012-04-04 21:48:31 +00:00
|
|
|
|
|
|
|
MODULE_LICENSE("GPL v2");
|