Loading...
1// SPDX-License-Identifier: GPL-2.0
2// Copyright (C) 2018 ROHM Semiconductors
3// gpio-bd70528.c ROHM BD70528MWV gpio driver
4
5#include <linux/gpio/driver.h>
6#include <linux/mfd/rohm-bd70528.h>
7#include <linux/module.h>
8#include <linux/platform_device.h>
9#include <linux/regmap.h>
10
11#define GPIO_IN_REG(offset) (BD70528_REG_GPIO1_IN + (offset) * 2)
12#define GPIO_OUT_REG(offset) (BD70528_REG_GPIO1_OUT + (offset) * 2)
13
14struct bd70528_gpio {
15 struct rohm_regmap_dev chip;
16 struct gpio_chip gpio;
17};
18
19static int bd70528_set_debounce(struct bd70528_gpio *bdgpio,
20 unsigned int offset, unsigned int debounce)
21{
22 u8 val;
23
24 switch (debounce) {
25 case 0:
26 val = BD70528_DEBOUNCE_DISABLE;
27 break;
28 case 1 ... 15000:
29 val = BD70528_DEBOUNCE_15MS;
30 break;
31 case 15001 ... 30000:
32 val = BD70528_DEBOUNCE_30MS;
33 break;
34 case 30001 ... 50000:
35 val = BD70528_DEBOUNCE_50MS;
36 break;
37 default:
38 dev_err(bdgpio->chip.dev,
39 "Invalid debounce value %u\n", debounce);
40 return -EINVAL;
41 }
42 return regmap_update_bits(bdgpio->chip.regmap, GPIO_IN_REG(offset),
43 BD70528_DEBOUNCE_MASK, val);
44}
45
46static int bd70528_get_direction(struct gpio_chip *chip, unsigned int offset)
47{
48 struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
49 int val, ret;
50
51 /* Do we need to do something to IRQs here? */
52 ret = regmap_read(bdgpio->chip.regmap, GPIO_OUT_REG(offset), &val);
53 if (ret) {
54 dev_err(bdgpio->chip.dev, "Could not read gpio direction\n");
55 return ret;
56 }
57 if (val & BD70528_GPIO_OUT_EN_MASK)
58 return GPIO_LINE_DIRECTION_OUT;
59
60 return GPIO_LINE_DIRECTION_IN;
61}
62
63static int bd70528_gpio_set_config(struct gpio_chip *chip, unsigned int offset,
64 unsigned long config)
65{
66 struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
67
68 switch (pinconf_to_config_param(config)) {
69 case PIN_CONFIG_DRIVE_OPEN_DRAIN:
70 return regmap_update_bits(bdgpio->chip.regmap,
71 GPIO_OUT_REG(offset),
72 BD70528_GPIO_DRIVE_MASK,
73 BD70528_GPIO_OPEN_DRAIN);
74 break;
75 case PIN_CONFIG_DRIVE_PUSH_PULL:
76 return regmap_update_bits(bdgpio->chip.regmap,
77 GPIO_OUT_REG(offset),
78 BD70528_GPIO_DRIVE_MASK,
79 BD70528_GPIO_PUSH_PULL);
80 break;
81 case PIN_CONFIG_INPUT_DEBOUNCE:
82 return bd70528_set_debounce(bdgpio, offset,
83 pinconf_to_config_argument(config));
84 break;
85 default:
86 break;
87 }
88 return -ENOTSUPP;
89}
90
91static int bd70528_direction_input(struct gpio_chip *chip, unsigned int offset)
92{
93 struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
94
95 /* Do we need to do something to IRQs here? */
96 return regmap_update_bits(bdgpio->chip.regmap, GPIO_OUT_REG(offset),
97 BD70528_GPIO_OUT_EN_MASK,
98 BD70528_GPIO_OUT_DISABLE);
99}
100
101static void bd70528_gpio_set(struct gpio_chip *chip, unsigned int offset,
102 int value)
103{
104 int ret;
105 struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
106 u8 val = (value) ? BD70528_GPIO_OUT_HI : BD70528_GPIO_OUT_LO;
107
108 ret = regmap_update_bits(bdgpio->chip.regmap, GPIO_OUT_REG(offset),
109 BD70528_GPIO_OUT_MASK, val);
110 if (ret)
111 dev_err(bdgpio->chip.dev, "Could not set gpio to %d\n", value);
112}
113
114static int bd70528_direction_output(struct gpio_chip *chip, unsigned int offset,
115 int value)
116{
117 struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
118
119 bd70528_gpio_set(chip, offset, value);
120 return regmap_update_bits(bdgpio->chip.regmap, GPIO_OUT_REG(offset),
121 BD70528_GPIO_OUT_EN_MASK,
122 BD70528_GPIO_OUT_ENABLE);
123}
124
125#define GPIO_IN_STATE_MASK(offset) (BD70528_GPIO_IN_STATE_BASE << (offset))
126
127static int bd70528_gpio_get_o(struct bd70528_gpio *bdgpio, unsigned int offset)
128{
129 int ret;
130 unsigned int val;
131
132 ret = regmap_read(bdgpio->chip.regmap, GPIO_OUT_REG(offset), &val);
133 if (!ret)
134 ret = !!(val & BD70528_GPIO_OUT_MASK);
135 else
136 dev_err(bdgpio->chip.dev, "GPIO (out) state read failed\n");
137
138 return ret;
139}
140
141static int bd70528_gpio_get_i(struct bd70528_gpio *bdgpio, unsigned int offset)
142{
143 unsigned int val;
144 int ret;
145
146 ret = regmap_read(bdgpio->chip.regmap, BD70528_REG_GPIO_STATE, &val);
147
148 if (!ret)
149 ret = !(val & GPIO_IN_STATE_MASK(offset));
150 else
151 dev_err(bdgpio->chip.dev, "GPIO (in) state read failed\n");
152
153 return ret;
154}
155
156static int bd70528_gpio_get(struct gpio_chip *chip, unsigned int offset)
157{
158 int ret;
159 struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
160
161 /*
162 * There is a race condition where someone might be changing the
163 * GPIO direction after we get it but before we read the value. But
164 * application design where GPIO direction may be changed just when
165 * we read GPIO value would be pointless as reader could not know
166 * whether the returned high/low state is caused by input or output.
167 * Or then there must be other ways to mitigate the issue. Thus
168 * locking would make no sense.
169 */
170 ret = bd70528_get_direction(chip, offset);
171 if (ret == GPIO_LINE_DIRECTION_OUT)
172 ret = bd70528_gpio_get_o(bdgpio, offset);
173 else if (ret == GPIO_LINE_DIRECTION_IN)
174 ret = bd70528_gpio_get_i(bdgpio, offset);
175 else
176 dev_err(bdgpio->chip.dev, "failed to read GPIO direction\n");
177
178 return ret;
179}
180
181static int bd70528_probe(struct platform_device *pdev)
182{
183 struct bd70528_gpio *bdgpio;
184 struct rohm_regmap_dev *bd70528;
185 int ret;
186
187 bd70528 = dev_get_drvdata(pdev->dev.parent);
188 if (!bd70528) {
189 dev_err(&pdev->dev, "No MFD driver data\n");
190 return -EINVAL;
191 }
192
193 bdgpio = devm_kzalloc(&pdev->dev, sizeof(*bdgpio),
194 GFP_KERNEL);
195 if (!bdgpio)
196 return -ENOMEM;
197 bdgpio->chip.dev = &pdev->dev;
198 bdgpio->gpio.parent = pdev->dev.parent;
199 bdgpio->gpio.label = "bd70528-gpio";
200 bdgpio->gpio.owner = THIS_MODULE;
201 bdgpio->gpio.get_direction = bd70528_get_direction;
202 bdgpio->gpio.direction_input = bd70528_direction_input;
203 bdgpio->gpio.direction_output = bd70528_direction_output;
204 bdgpio->gpio.set_config = bd70528_gpio_set_config;
205 bdgpio->gpio.can_sleep = true;
206 bdgpio->gpio.get = bd70528_gpio_get;
207 bdgpio->gpio.set = bd70528_gpio_set;
208 bdgpio->gpio.ngpio = 4;
209 bdgpio->gpio.base = -1;
210#ifdef CONFIG_OF_GPIO
211 bdgpio->gpio.of_node = pdev->dev.parent->of_node;
212#endif
213 bdgpio->chip.regmap = bd70528->regmap;
214
215 ret = devm_gpiochip_add_data(&pdev->dev, &bdgpio->gpio,
216 bdgpio);
217 if (ret)
218 dev_err(&pdev->dev, "gpio_init: Failed to add bd70528-gpio\n");
219
220 return ret;
221}
222
223static struct platform_driver bd70528_gpio = {
224 .driver = {
225 .name = "bd70528-gpio"
226 },
227 .probe = bd70528_probe,
228};
229
230module_platform_driver(bd70528_gpio);
231
232MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
233MODULE_DESCRIPTION("BD70528 voltage regulator driver");
234MODULE_LICENSE("GPL");
235MODULE_ALIAS("platform:bd70528-gpio");
1// SPDX-License-Identifier: GPL-2.0
2// Copyright (C) 2018 ROHM Semiconductors
3// gpio-bd70528.c ROHM BD70528MWV gpio driver
4
5#include <linux/gpio/driver.h>
6#include <linux/mfd/rohm-bd70528.h>
7#include <linux/module.h>
8#include <linux/platform_device.h>
9#include <linux/regmap.h>
10
11#define GPIO_IN_REG(offset) (BD70528_REG_GPIO1_IN + (offset) * 2)
12#define GPIO_OUT_REG(offset) (BD70528_REG_GPIO1_OUT + (offset) * 2)
13
14struct bd70528_gpio {
15 struct regmap *regmap;
16 struct device *dev;
17 struct gpio_chip gpio;
18};
19
20static int bd70528_set_debounce(struct bd70528_gpio *bdgpio,
21 unsigned int offset, unsigned int debounce)
22{
23 u8 val;
24
25 switch (debounce) {
26 case 0:
27 val = BD70528_DEBOUNCE_DISABLE;
28 break;
29 case 1 ... 15000:
30 val = BD70528_DEBOUNCE_15MS;
31 break;
32 case 15001 ... 30000:
33 val = BD70528_DEBOUNCE_30MS;
34 break;
35 case 30001 ... 50000:
36 val = BD70528_DEBOUNCE_50MS;
37 break;
38 default:
39 dev_err(bdgpio->dev,
40 "Invalid debounce value %u\n", debounce);
41 return -EINVAL;
42 }
43 return regmap_update_bits(bdgpio->regmap, GPIO_IN_REG(offset),
44 BD70528_DEBOUNCE_MASK, val);
45}
46
47static int bd70528_get_direction(struct gpio_chip *chip, unsigned int offset)
48{
49 struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
50 int val, ret;
51
52 /* Do we need to do something to IRQs here? */
53 ret = regmap_read(bdgpio->regmap, GPIO_OUT_REG(offset), &val);
54 if (ret) {
55 dev_err(bdgpio->dev, "Could not read gpio direction\n");
56 return ret;
57 }
58 if (val & BD70528_GPIO_OUT_EN_MASK)
59 return GPIO_LINE_DIRECTION_OUT;
60
61 return GPIO_LINE_DIRECTION_IN;
62}
63
64static int bd70528_gpio_set_config(struct gpio_chip *chip, unsigned int offset,
65 unsigned long config)
66{
67 struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
68
69 switch (pinconf_to_config_param(config)) {
70 case PIN_CONFIG_DRIVE_OPEN_DRAIN:
71 return regmap_update_bits(bdgpio->regmap,
72 GPIO_OUT_REG(offset),
73 BD70528_GPIO_DRIVE_MASK,
74 BD70528_GPIO_OPEN_DRAIN);
75 break;
76 case PIN_CONFIG_DRIVE_PUSH_PULL:
77 return regmap_update_bits(bdgpio->regmap,
78 GPIO_OUT_REG(offset),
79 BD70528_GPIO_DRIVE_MASK,
80 BD70528_GPIO_PUSH_PULL);
81 break;
82 case PIN_CONFIG_INPUT_DEBOUNCE:
83 return bd70528_set_debounce(bdgpio, offset,
84 pinconf_to_config_argument(config));
85 break;
86 default:
87 break;
88 }
89 return -ENOTSUPP;
90}
91
92static int bd70528_direction_input(struct gpio_chip *chip, unsigned int offset)
93{
94 struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
95
96 /* Do we need to do something to IRQs here? */
97 return regmap_update_bits(bdgpio->regmap, GPIO_OUT_REG(offset),
98 BD70528_GPIO_OUT_EN_MASK,
99 BD70528_GPIO_OUT_DISABLE);
100}
101
102static void bd70528_gpio_set(struct gpio_chip *chip, unsigned int offset,
103 int value)
104{
105 int ret;
106 struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
107 u8 val = (value) ? BD70528_GPIO_OUT_HI : BD70528_GPIO_OUT_LO;
108
109 ret = regmap_update_bits(bdgpio->regmap, GPIO_OUT_REG(offset),
110 BD70528_GPIO_OUT_MASK, val);
111 if (ret)
112 dev_err(bdgpio->dev, "Could not set gpio to %d\n", value);
113}
114
115static int bd70528_direction_output(struct gpio_chip *chip, unsigned int offset,
116 int value)
117{
118 struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
119
120 bd70528_gpio_set(chip, offset, value);
121 return regmap_update_bits(bdgpio->regmap, GPIO_OUT_REG(offset),
122 BD70528_GPIO_OUT_EN_MASK,
123 BD70528_GPIO_OUT_ENABLE);
124}
125
126#define GPIO_IN_STATE_MASK(offset) (BD70528_GPIO_IN_STATE_BASE << (offset))
127
128static int bd70528_gpio_get_o(struct bd70528_gpio *bdgpio, unsigned int offset)
129{
130 int ret;
131 unsigned int val;
132
133 ret = regmap_read(bdgpio->regmap, GPIO_OUT_REG(offset), &val);
134 if (!ret)
135 ret = !!(val & BD70528_GPIO_OUT_MASK);
136 else
137 dev_err(bdgpio->dev, "GPIO (out) state read failed\n");
138
139 return ret;
140}
141
142static int bd70528_gpio_get_i(struct bd70528_gpio *bdgpio, unsigned int offset)
143{
144 unsigned int val;
145 int ret;
146
147 ret = regmap_read(bdgpio->regmap, BD70528_REG_GPIO_STATE, &val);
148
149 if (!ret)
150 ret = !(val & GPIO_IN_STATE_MASK(offset));
151 else
152 dev_err(bdgpio->dev, "GPIO (in) state read failed\n");
153
154 return ret;
155}
156
157static int bd70528_gpio_get(struct gpio_chip *chip, unsigned int offset)
158{
159 int ret;
160 struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
161
162 /*
163 * There is a race condition where someone might be changing the
164 * GPIO direction after we get it but before we read the value. But
165 * application design where GPIO direction may be changed just when
166 * we read GPIO value would be pointless as reader could not know
167 * whether the returned high/low state is caused by input or output.
168 * Or then there must be other ways to mitigate the issue. Thus
169 * locking would make no sense.
170 */
171 ret = bd70528_get_direction(chip, offset);
172 if (ret == GPIO_LINE_DIRECTION_OUT)
173 ret = bd70528_gpio_get_o(bdgpio, offset);
174 else if (ret == GPIO_LINE_DIRECTION_IN)
175 ret = bd70528_gpio_get_i(bdgpio, offset);
176 else
177 dev_err(bdgpio->dev, "failed to read GPIO direction\n");
178
179 return ret;
180}
181
182static int bd70528_probe(struct platform_device *pdev)
183{
184 struct device *dev = &pdev->dev;
185 struct bd70528_gpio *bdgpio;
186 int ret;
187
188 bdgpio = devm_kzalloc(dev, sizeof(*bdgpio), GFP_KERNEL);
189 if (!bdgpio)
190 return -ENOMEM;
191 bdgpio->dev = dev;
192 bdgpio->gpio.parent = dev->parent;
193 bdgpio->gpio.label = "bd70528-gpio";
194 bdgpio->gpio.owner = THIS_MODULE;
195 bdgpio->gpio.get_direction = bd70528_get_direction;
196 bdgpio->gpio.direction_input = bd70528_direction_input;
197 bdgpio->gpio.direction_output = bd70528_direction_output;
198 bdgpio->gpio.set_config = bd70528_gpio_set_config;
199 bdgpio->gpio.can_sleep = true;
200 bdgpio->gpio.get = bd70528_gpio_get;
201 bdgpio->gpio.set = bd70528_gpio_set;
202 bdgpio->gpio.ngpio = 4;
203 bdgpio->gpio.base = -1;
204#ifdef CONFIG_OF_GPIO
205 bdgpio->gpio.of_node = dev->parent->of_node;
206#endif
207 bdgpio->regmap = dev_get_regmap(dev->parent, NULL);
208 if (!bdgpio->regmap)
209 return -ENODEV;
210
211 ret = devm_gpiochip_add_data(dev, &bdgpio->gpio, bdgpio);
212 if (ret)
213 dev_err(dev, "gpio_init: Failed to add bd70528-gpio\n");
214
215 return ret;
216}
217
218static struct platform_driver bd70528_gpio = {
219 .driver = {
220 .name = "bd70528-gpio"
221 },
222 .probe = bd70528_probe,
223};
224
225module_platform_driver(bd70528_gpio);
226
227MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
228MODULE_DESCRIPTION("BD70528 voltage regulator driver");
229MODULE_LICENSE("GPL");
230MODULE_ALIAS("platform:bd70528-gpio");