Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
reset: amlogic: convert driver to regmap
To allow using the same driver for the main reset controller and the
auxiliary ones embedded in the clock controllers, convert the
the Amlogic reset driver to regmap.
Reviewed-by: Neil Armstrong <neil.armstrong@linaro.org>
Signed-off-by: Jerome Brunet <jbrunet@baylibre.com>
Reviewed-by: Philipp Zabel <p.zabel@pengutronix.de>
Link: https://lore.kernel.org/r/20240910-meson-rst-aux-v5-1-60be62635d3e@baylibre.com
Signed-off-by: Philipp Zabel <p.zabel@pengutronix.de>
authored by
Jerome Brunet
and committed by
Philipp Zabel
7af26f3c
9852d85e
+44
-36
+1
drivers/reset/Kconfig
+1
drivers/reset/Kconfig
+43
-36
drivers/reset/reset-meson.c
+43
-36
drivers/reset/reset-meson.c
···
11
11
#include <linux/of.h>
12
12
#include <linux/module.h>
13
13
#include <linux/platform_device.h>
14
+
#include <linux/regmap.h>
14
15
#include <linux/reset-controller.h>
15
16
#include <linux/slab.h>
16
17
#include <linux/types.h>
17
-
18
-
#define BITS_PER_REG 32
19
18
20
19
struct meson_reset_param {
21
20
int reg_count;
···
22
23
};
23
24
24
25
struct meson_reset {
25
-
void __iomem *reg_base;
26
26
const struct meson_reset_param *param;
27
27
struct reset_controller_dev rcdev;
28
-
spinlock_t lock;
28
+
struct regmap *map;
29
29
};
30
30
31
+
static void meson_reset_offset_and_bit(struct meson_reset *data,
32
+
unsigned long id,
33
+
unsigned int *offset,
34
+
unsigned int *bit)
35
+
{
36
+
unsigned int stride = regmap_get_reg_stride(data->map);
37
+
38
+
*offset = (id / (stride * BITS_PER_BYTE)) * stride;
39
+
*bit = id % (stride * BITS_PER_BYTE);
40
+
}
41
+
31
42
static int meson_reset_reset(struct reset_controller_dev *rcdev,
32
-
unsigned long id)
43
+
unsigned long id)
33
44
{
34
45
struct meson_reset *data =
35
46
container_of(rcdev, struct meson_reset, rcdev);
36
-
unsigned int bank = id / BITS_PER_REG;
37
-
unsigned int offset = id % BITS_PER_REG;
38
-
void __iomem *reg_addr = data->reg_base + (bank << 2);
47
+
unsigned int offset, bit;
39
48
40
-
writel(BIT(offset), reg_addr);
49
+
meson_reset_offset_and_bit(data, id, &offset, &bit);
41
50
42
-
return 0;
51
+
return regmap_write(data->map, offset, BIT(bit));
43
52
}
44
53
45
54
static int meson_reset_level(struct reset_controller_dev *rcdev,
···
55
48
{
56
49
struct meson_reset *data =
57
50
container_of(rcdev, struct meson_reset, rcdev);
58
-
unsigned int bank = id / BITS_PER_REG;
59
-
unsigned int offset = id % BITS_PER_REG;
60
-
void __iomem *reg_addr;
61
-
unsigned long flags;
62
-
u32 reg;
51
+
unsigned int offset, bit;
63
52
64
-
reg_addr = data->reg_base + data->param->level_offset + (bank << 2);
53
+
meson_reset_offset_and_bit(data, id, &offset, &bit);
54
+
offset += data->param->level_offset;
65
55
66
-
spin_lock_irqsave(&data->lock, flags);
67
-
68
-
reg = readl(reg_addr);
69
-
if (assert)
70
-
writel(reg & ~BIT(offset), reg_addr);
71
-
else
72
-
writel(reg | BIT(offset), reg_addr);
73
-
74
-
spin_unlock_irqrestore(&data->lock, flags);
75
-
76
-
return 0;
56
+
return regmap_update_bits(data->map, offset,
57
+
BIT(bit), assert ? 0 : BIT(bit));
77
58
}
78
59
79
60
static int meson_reset_assert(struct reset_controller_dev *rcdev,
···
114
119
};
115
120
MODULE_DEVICE_TABLE(of, meson_reset_dt_ids);
116
121
122
+
static const struct regmap_config regmap_config = {
123
+
.reg_bits = 32,
124
+
.val_bits = 32,
125
+
.reg_stride = 4,
126
+
};
127
+
117
128
static int meson_reset_probe(struct platform_device *pdev)
118
129
{
130
+
struct device *dev = &pdev->dev;
119
131
struct meson_reset *data;
132
+
void __iomem *base;
120
133
121
-
data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
134
+
data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
122
135
if (!data)
123
136
return -ENOMEM;
124
137
125
-
data->reg_base = devm_platform_ioremap_resource(pdev, 0);
126
-
if (IS_ERR(data->reg_base))
127
-
return PTR_ERR(data->reg_base);
138
+
base = devm_platform_ioremap_resource(pdev, 0);
139
+
if (IS_ERR(base))
140
+
return PTR_ERR(base);
128
141
129
-
data->param = of_device_get_match_data(&pdev->dev);
142
+
data->param = of_device_get_match_data(dev);
130
143
if (!data->param)
131
144
return -ENODEV;
132
145
133
-
spin_lock_init(&data->lock);
146
+
data->map = devm_regmap_init_mmio(dev, base, ®map_config);
147
+
if (IS_ERR(data->map))
148
+
return dev_err_probe(dev, PTR_ERR(data->map),
149
+
"can't init regmap mmio region\n");
134
150
135
151
data->rcdev.owner = THIS_MODULE;
136
-
data->rcdev.nr_resets = data->param->reg_count * BITS_PER_REG;
152
+
data->rcdev.nr_resets = data->param->reg_count * BITS_PER_BYTE
153
+
* regmap_config.reg_stride;
137
154
data->rcdev.ops = &meson_reset_ops;
138
-
data->rcdev.of_node = pdev->dev.of_node;
155
+
data->rcdev.of_node = dev->of_node;
139
156
140
-
return devm_reset_controller_register(&pdev->dev, &data->rcdev);
157
+
return devm_reset_controller_register(dev, &data->rcdev);
141
158
}
142
159
143
160
static struct platform_driver meson_reset_driver = {