1
2
3
4
5
6
7
8#include <common.h>
9#include <dm.h>
10#include <i2c.h>
11#include <asm/gpio.h>
12#include <dm/device.h>
13#include <dm/device-internal.h>
14#include <dm/lists.h>
15#include <dm/pinctrl.h>
16#include <linux/bitfield.h>
17#include <power/regulator.h>
18
19
20#define STMFX_MAX_GPIO 16
21#define STMFX_MAX_AGPIO 8
22
23
24#define STMFX_REG_CHIP_ID 0x00
25#define STMFX_REG_FW_VERSION_MSB 0x01
26#define STMFX_REG_FW_VERSION_LSB 0x02
27#define STMFX_REG_SYS_CTRL 0x40
28
29
30#define STMFX_BOOT_TIME_MS 10
31
32
33
34#define STMFX_REG_GPIO_STATE 0x10
35
36#define STMFX_REG_GPIO_DIR 0x60
37
38#define STMFX_REG_GPIO_TYPE 0x64
39
40#define STMFX_REG_GPIO_PUPD 0x68
41
42#define STMFX_REG_GPO_SET 0x6C
43
44#define STMFX_REG_GPO_CLR 0x70
45
46
47#define STMFX_REG_CHIP_ID_MASK GENMASK(7, 0)
48
49
50#define STMFX_REG_SYS_CTRL_GPIO_EN BIT(0)
51#define STMFX_REG_SYS_CTRL_ALTGPIO_EN BIT(3)
52#define STMFX_REG_SYS_CTRL_SWRST BIT(7)
53
54#define NR_GPIO_REGS 3
55#define NR_GPIOS_PER_REG 8
56#define get_reg(offset) ((offset) / NR_GPIOS_PER_REG)
57#define get_shift(offset) ((offset) % NR_GPIOS_PER_REG)
58#define get_mask(offset) (BIT(get_shift(offset)))
59
60struct stmfx_pinctrl {
61 struct udevice *gpio;
62};
63
64static int stmfx_read(struct udevice *dev, uint offset)
65{
66 return dm_i2c_reg_read(dev_get_parent(dev), offset);
67}
68
69static int stmfx_write(struct udevice *dev, uint offset, unsigned int val)
70{
71 return dm_i2c_reg_write(dev_get_parent(dev), offset, val);
72}
73
74static int stmfx_gpio_get(struct udevice *dev, unsigned int offset)
75{
76 u32 reg = STMFX_REG_GPIO_STATE + get_reg(offset);
77 u32 mask = get_mask(offset);
78 int ret;
79
80 ret = stmfx_read(dev, reg);
81
82 return ret < 0 ? ret : !!(ret & mask);
83}
84
85static int stmfx_gpio_set(struct udevice *dev, unsigned int offset, int value)
86{
87 u32 reg = value ? STMFX_REG_GPO_SET : STMFX_REG_GPO_CLR;
88 u32 mask = get_mask(offset);
89
90 return stmfx_write(dev, reg + get_reg(offset), mask);
91}
92
93static int stmfx_gpio_get_function(struct udevice *dev, unsigned int offset)
94{
95 u32 reg = STMFX_REG_GPIO_DIR + get_reg(offset);
96 u32 mask = get_mask(offset);
97 int ret;
98
99 ret = stmfx_read(dev, reg);
100
101 if (ret < 0)
102 return ret;
103
104
105 return ret & mask ? GPIOF_OUTPUT : GPIOF_INPUT;
106}
107
108static int stmfx_gpio_direction_input(struct udevice *dev, unsigned int offset)
109{
110 u32 reg = STMFX_REG_GPIO_DIR + get_reg(offset);
111 u32 mask = get_mask(offset);
112 int ret;
113
114 ret = stmfx_read(dev, reg);
115 if (ret < 0)
116 return ret;
117
118 ret &= ~mask;
119
120 return stmfx_write(dev, reg, ret & ~mask);
121}
122
123static int stmfx_gpio_direction_output(struct udevice *dev,
124 unsigned int offset, int value)
125{
126 u32 reg = STMFX_REG_GPIO_DIR + get_reg(offset);
127 u32 mask = get_mask(offset);
128 int ret;
129
130 ret = stmfx_gpio_set(dev, offset, value);
131 if (ret < 0)
132 return ret;
133
134 ret = stmfx_read(dev, reg);
135 if (ret < 0)
136 return ret;
137
138 return stmfx_write(dev, reg, ret | mask);
139}
140
141static int stmfx_gpio_probe(struct udevice *dev)
142{
143 struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
144 struct ofnode_phandle_args args;
145 u8 sys_ctrl;
146
147 uc_priv->bank_name = "stmfx";
148 uc_priv->gpio_count = STMFX_MAX_GPIO + STMFX_MAX_AGPIO;
149 if (!dev_read_phandle_with_args(dev, "gpio-ranges",
150 NULL, 3, 0, &args)) {
151 uc_priv->gpio_count = args.args[2];
152 }
153
154
155 sys_ctrl = STMFX_REG_SYS_CTRL_GPIO_EN;
156 if (uc_priv->gpio_count > STMFX_MAX_GPIO)
157 sys_ctrl |= STMFX_REG_SYS_CTRL_ALTGPIO_EN;
158 stmfx_write(dev, STMFX_REG_SYS_CTRL, sys_ctrl);
159
160 return 0;
161}
162
163static const struct dm_gpio_ops stmfx_gpio_ops = {
164 .set_value = stmfx_gpio_set,
165 .get_value = stmfx_gpio_get,
166 .get_function = stmfx_gpio_get_function,
167 .direction_input = stmfx_gpio_direction_input,
168 .direction_output = stmfx_gpio_direction_output,
169};
170
171U_BOOT_DRIVER(stmfx_gpio) = {
172 .name = "stmfx-gpio",
173 .id = UCLASS_GPIO,
174 .probe = stmfx_gpio_probe,
175 .ops = &stmfx_gpio_ops,
176};
177
178#if CONFIG_IS_ENABLED(PINCONF)
179static const struct pinconf_param stmfx_pinctrl_conf_params[] = {
180 { "bias-disable", PIN_CONFIG_BIAS_DISABLE, 0 },
181 { "bias-pull-up", PIN_CONFIG_BIAS_PULL_UP, 0 },
182 { "bias-pull-pin-default", PIN_CONFIG_BIAS_PULL_PIN_DEFAULT, 0 },
183 { "bias-pull-down", PIN_CONFIG_BIAS_PULL_DOWN, 0 },
184 { "drive-open-drain", PIN_CONFIG_DRIVE_OPEN_DRAIN, 0 },
185 { "drive-push-pull", PIN_CONFIG_DRIVE_PUSH_PULL, 0 },
186 { "output-high", PIN_CONFIG_OUTPUT, 1 },
187 { "output-low", PIN_CONFIG_OUTPUT, 0 },
188};
189
190static int stmfx_pinctrl_set_pupd(struct udevice *dev,
191 unsigned int pin, u32 pupd)
192{
193 u8 reg = STMFX_REG_GPIO_PUPD + get_reg(pin);
194 u32 mask = get_mask(pin);
195 int ret;
196
197 ret = stmfx_read(dev, reg);
198 if (ret < 0)
199 return ret;
200 ret = (ret & ~mask) | (pupd ? mask : 0);
201
202 return stmfx_write(dev, reg, ret);
203}
204
205static int stmfx_pinctrl_set_type(struct udevice *dev,
206 unsigned int pin, u32 type)
207{
208 u8 reg = STMFX_REG_GPIO_TYPE + get_reg(pin);
209 u32 mask = get_mask(pin);
210 int ret;
211
212 ret = stmfx_read(dev, reg);
213 if (ret < 0)
214 return ret;
215 ret = (ret & ~mask) | (type ? mask : 0);
216
217 return stmfx_write(dev, reg, ret);
218}
219
220static int stmfx_pinctrl_conf_set(struct udevice *dev, unsigned int pin,
221 unsigned int param, unsigned int arg)
222{
223 int ret, dir;
224 struct stmfx_pinctrl *plat = dev_get_platdata(dev);
225
226 dir = stmfx_gpio_get_function(plat->gpio, pin);
227
228 if (dir < 0)
229 return dir;
230
231 switch (param) {
232 case PIN_CONFIG_BIAS_PULL_PIN_DEFAULT:
233 case PIN_CONFIG_BIAS_DISABLE:
234 case PIN_CONFIG_DRIVE_PUSH_PULL:
235 ret = stmfx_pinctrl_set_type(dev, pin, 0);
236 break;
237 case PIN_CONFIG_BIAS_PULL_DOWN:
238 ret = stmfx_pinctrl_set_type(dev, pin, 1);
239 if (ret)
240 return ret;
241 ret = stmfx_pinctrl_set_pupd(dev, pin, 0);
242 break;
243 case PIN_CONFIG_BIAS_PULL_UP:
244 ret = stmfx_pinctrl_set_type(dev, pin, 1);
245 if (ret)
246 return ret;
247 ret = stmfx_pinctrl_set_pupd(dev, pin, 1);
248 break;
249 case PIN_CONFIG_DRIVE_OPEN_DRAIN:
250 ret = stmfx_pinctrl_set_type(dev, pin, 1);
251 break;
252 case PIN_CONFIG_OUTPUT:
253 ret = stmfx_gpio_direction_output(plat->gpio, pin, arg);
254 break;
255 default:
256 return -ENOTSUPP;
257 }
258
259 return ret;
260}
261#endif
262
263static int stmfx_pinctrl_get_pins_count(struct udevice *dev)
264{
265 struct stmfx_pinctrl *plat = dev_get_platdata(dev);
266 struct gpio_dev_priv *uc_priv;
267
268 uc_priv = dev_get_uclass_priv(plat->gpio);
269
270 return uc_priv->gpio_count;
271}
272
273
274
275
276
277#define MAX_PIN_NAME_LEN 7
278static char pin_name[MAX_PIN_NAME_LEN];
279static const char *stmfx_pinctrl_get_pin_name(struct udevice *dev,
280 unsigned int selector)
281{
282 if (selector < STMFX_MAX_GPIO)
283 snprintf(pin_name, MAX_PIN_NAME_LEN, "gpio%u", selector);
284 else
285 snprintf(pin_name, MAX_PIN_NAME_LEN, "agpio%u", selector - 16);
286 return pin_name;
287}
288
289static int stmfx_pinctrl_get_pin_muxing(struct udevice *dev,
290 unsigned int selector,
291 char *buf, int size)
292{
293 struct stmfx_pinctrl *plat = dev_get_platdata(dev);
294 int func;
295
296 func = stmfx_gpio_get_function(plat->gpio, selector);
297 if (func < 0)
298 return func;
299
300 snprintf(buf, size, "%s", func == GPIOF_INPUT ? "input" : "output");
301
302 return 0;
303}
304
305static int stmfx_pinctrl_bind(struct udevice *dev)
306{
307 struct stmfx_pinctrl *plat = dev_get_platdata(dev);
308
309 return device_bind_driver_to_node(dev->parent,
310 "stmfx-gpio", "stmfx-gpio",
311 dev_ofnode(dev), &plat->gpio);
312};
313
314static int stmfx_pinctrl_probe(struct udevice *dev)
315{
316 struct stmfx_pinctrl *plat = dev_get_platdata(dev);
317
318 return device_probe(plat->gpio);
319};
320
321const struct pinctrl_ops stmfx_pinctrl_ops = {
322 .get_pins_count = stmfx_pinctrl_get_pins_count,
323 .get_pin_name = stmfx_pinctrl_get_pin_name,
324 .set_state = pinctrl_generic_set_state,
325 .get_pin_muxing = stmfx_pinctrl_get_pin_muxing,
326#if CONFIG_IS_ENABLED(PINCONF)
327 .pinconf_set = stmfx_pinctrl_conf_set,
328 .pinconf_num_params = ARRAY_SIZE(stmfx_pinctrl_conf_params),
329 .pinconf_params = stmfx_pinctrl_conf_params,
330#endif
331};
332
333static const struct udevice_id stmfx_pinctrl_match[] = {
334 { .compatible = "st,stmfx-0300-pinctrl", },
335};
336
337U_BOOT_DRIVER(stmfx_pinctrl) = {
338 .name = "stmfx-pinctrl",
339 .id = UCLASS_PINCTRL,
340 .of_match = of_match_ptr(stmfx_pinctrl_match),
341 .bind = stmfx_pinctrl_bind,
342 .probe = stmfx_pinctrl_probe,
343 .ops = &stmfx_pinctrl_ops,
344 .platdata_auto_alloc_size = sizeof(struct stmfx_pinctrl),
345};
346
347static int stmfx_chip_init(struct udevice *dev)
348{
349 u8 id;
350 u8 version[2];
351 int ret;
352 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
353
354 id = dm_i2c_reg_read(dev, STMFX_REG_CHIP_ID);
355 if (id < 0) {
356 dev_err(dev, "error reading chip id: %d\n", id);
357 return ret;
358 }
359
360
361
362
363
364
365
366
367
368
369
370 if (FIELD_GET(STMFX_REG_CHIP_ID_MASK, ~id) != (chip->chip_addr << 1)) {
371 dev_err(dev, "unknown chip id: %#x\n", id);
372 return -EINVAL;
373 }
374
375 ret = dm_i2c_read(dev, STMFX_REG_FW_VERSION_MSB,
376 version, sizeof(version));
377 if (ret) {
378 dev_err(dev, "error reading fw version: %d\n", ret);
379 return ret;
380 }
381
382 dev_info(dev, "STMFX id: %#x, fw version: %x.%02x\n",
383 id, version[0], version[1]);
384
385 ret = dm_i2c_reg_read(dev, STMFX_REG_SYS_CTRL);
386
387 if (ret < 0)
388 return ret;
389
390 ret = dm_i2c_reg_write(dev, STMFX_REG_SYS_CTRL,
391 ret | STMFX_REG_SYS_CTRL_SWRST);
392 if (ret)
393 return ret;
394
395 mdelay(STMFX_BOOT_TIME_MS);
396
397 return ret;
398}
399
400static int stmfx_probe(struct udevice *dev)
401{
402 struct udevice *vdd;
403 int ret;
404
405 ret = device_get_supply_regulator(dev, "vdd-supply", &vdd);
406 if (ret && ret != -ENOENT) {
407 dev_err(dev, "vdd regulator error:%d\n", ret);
408 return ret;
409 }
410 if (!ret) {
411 ret = regulator_set_enable(vdd, true);
412 if (ret) {
413 dev_err(dev, "vdd enable failed: %d\n", ret);
414 return ret;
415 }
416 }
417
418 return stmfx_chip_init(dev);
419}
420
421static const struct udevice_id stmfx_match[] = {
422 { .compatible = "st,stmfx-0300", },
423};
424
425U_BOOT_DRIVER(stmfx) = {
426 .name = "stmfx",
427 .id = UCLASS_I2C_GENERIC,
428 .of_match = of_match_ptr(stmfx_match),
429 .probe = stmfx_probe,
430 .bind = dm_scan_fdt_dev,
431};
432
