1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (C) 2018, STMicroelectronics - All Rights Reserved
5 * Driver for STMicroelectronics Multi-Function eXpander (STMFX) GPIO expander
6 * based on Linux driver : pinctrl/pinctrl-stmfx.c
12 #include <dm/device.h>
13 #include <dm/device-internal.h>
14 #include <dm/device_compat.h>
16 #include <dm/pinctrl.h>
17 #include <linux/bitfield.h>
18 #include <linux/bitops.h>
19 #include <linux/delay.h>
20 #include <power/regulator.h>
22 /* STMFX pins = GPIO[15:0] + aGPIO[7:0] */
23 #define STMFX_MAX_GPIO 16
24 #define STMFX_MAX_AGPIO 8
27 #define STMFX_REG_CHIP_ID 0x00 /* R */
28 #define STMFX_REG_FW_VERSION_MSB 0x01 /* R */
29 #define STMFX_REG_FW_VERSION_LSB 0x02 /* R */
30 #define STMFX_REG_SYS_CTRL 0x40 /* RW */
32 /* MFX boot time is around 10ms, so after reset, we have to wait this delay */
33 #define STMFX_BOOT_TIME_MS 10
36 /* GPIO_STATE1 0x10, GPIO_STATE2 0x11, GPIO_STATE3 0x12 */
37 #define STMFX_REG_GPIO_STATE 0x10 /* R */
38 /* GPIO_DIR1 0x60, GPIO_DIR2 0x61, GPIO_DIR3 0x63 */
39 #define STMFX_REG_GPIO_DIR 0x60 /* RW */
40 /* GPIO_TYPE1 0x64, GPIO_TYPE2 0x65, GPIO_TYPE3 0x66 */
41 #define STMFX_REG_GPIO_TYPE 0x64 /* RW */
42 /* GPIO_PUPD1 0x68, GPIO_PUPD2 0x69, GPIO_PUPD3 0x6A */
43 #define STMFX_REG_GPIO_PUPD 0x68 /* RW */
44 /* GPO_SET1 0x6C, GPO_SET2 0x6D, GPO_SET3 0x6E */
45 #define STMFX_REG_GPO_SET 0x6C /* RW */
46 /* GPO_CLR1 0x70, GPO_CLR2 0x71, GPO_CLR3 0x72 */
47 #define STMFX_REG_GPO_CLR 0x70 /* RW */
49 /* STMFX_REG_CHIP_ID bitfields */
50 #define STMFX_REG_CHIP_ID_MASK GENMASK(7, 0)
52 /* STMFX_REG_SYS_CTRL bitfields */
53 #define STMFX_REG_SYS_CTRL_GPIO_EN BIT(0)
54 #define STMFX_REG_SYS_CTRL_ALTGPIO_EN BIT(3)
55 #define STMFX_REG_SYS_CTRL_SWRST BIT(7)
57 #define NR_GPIO_REGS 3
58 #define NR_GPIOS_PER_REG 8
59 #define get_reg(offset) ((offset) / NR_GPIOS_PER_REG)
60 #define get_shift(offset) ((offset) % NR_GPIOS_PER_REG)
61 #define get_mask(offset) (BIT(get_shift(offset)))
63 struct stmfx_pinctrl {
67 static int stmfx_read(struct udevice *dev, uint offset)
69 return dm_i2c_reg_read(dev_get_parent(dev), offset);
72 static int stmfx_write(struct udevice *dev, uint offset, unsigned int val)
74 return dm_i2c_reg_write(dev_get_parent(dev), offset, val);
77 static int stmfx_read_reg(struct udevice *dev, u8 reg_base, uint offset)
79 u8 reg = reg_base + get_reg(offset);
80 u32 mask = get_mask(offset);
83 ret = stmfx_read(dev, reg);
87 return ret < 0 ? ret : !!(ret & mask);
90 static int stmfx_write_reg(struct udevice *dev, u8 reg_base, uint offset,
93 u8 reg = reg_base + get_reg(offset);
94 u32 mask = get_mask(offset);
97 ret = stmfx_read(dev, reg);
100 ret = (ret & ~mask) | (val ? mask : 0);
102 return stmfx_write(dev, reg, ret);
105 static int stmfx_conf_set_pupd(struct udevice *dev, unsigned int offset,
108 return stmfx_write_reg(dev, STMFX_REG_GPIO_PUPD, offset, pupd);
111 static int stmfx_conf_get_pupd(struct udevice *dev, unsigned int offset)
113 return stmfx_read_reg(dev, STMFX_REG_GPIO_PUPD, offset);
116 static int stmfx_conf_set_type(struct udevice *dev, unsigned int offset,
119 return stmfx_write_reg(dev, STMFX_REG_GPIO_TYPE, offset, type);
122 static int stmfx_conf_get_type(struct udevice *dev, unsigned int offset)
124 return stmfx_read_reg(dev, STMFX_REG_GPIO_TYPE, offset);
127 static int stmfx_gpio_get(struct udevice *dev, unsigned int offset)
129 return stmfx_read_reg(dev, STMFX_REG_GPIO_STATE, offset);
132 static int stmfx_gpio_set(struct udevice *dev, unsigned int offset, int value)
134 u32 reg = value ? STMFX_REG_GPO_SET : STMFX_REG_GPO_CLR;
135 u32 mask = get_mask(offset);
137 return stmfx_write(dev, reg + get_reg(offset), mask);
140 static int stmfx_gpio_get_function(struct udevice *dev, unsigned int offset)
142 int ret = stmfx_read_reg(dev, STMFX_REG_GPIO_DIR, offset);
146 /* On stmfx, gpio pins direction is (0)input, (1)output. */
148 return ret ? GPIOF_OUTPUT : GPIOF_INPUT;
151 static int stmfx_gpio_direction_input(struct udevice *dev, unsigned int offset)
153 return stmfx_write_reg(dev, STMFX_REG_GPIO_DIR, offset, 0);
156 static int stmfx_gpio_direction_output(struct udevice *dev,
157 unsigned int offset, int value)
159 int ret = stmfx_gpio_set(dev, offset, value);
163 return stmfx_write_reg(dev, STMFX_REG_GPIO_DIR, offset, 1);
166 static int stmfx_gpio_set_dir_flags(struct udevice *dev, unsigned int offset,
171 if (flags & GPIOD_IS_OUT) {
172 if (flags & GPIOD_OPEN_SOURCE)
174 if (flags & GPIOD_OPEN_DRAIN)
175 ret = stmfx_conf_set_type(dev, offset, 0);
177 ret = stmfx_conf_set_type(dev, offset, 1);
180 ret = stmfx_gpio_direction_output(dev, offset,
181 GPIOD_FLAGS_OUTPUT(flags));
182 } else if (flags & GPIOD_IS_IN) {
183 ret = stmfx_gpio_direction_input(dev, offset);
186 if (flags & GPIOD_PULL_UP) {
187 ret = stmfx_conf_set_type(dev, offset, 1);
190 ret = stmfx_conf_set_pupd(dev, offset, 1);
191 } else if (flags & GPIOD_PULL_DOWN) {
192 ret = stmfx_conf_set_type(dev, offset, 1);
195 ret = stmfx_conf_set_pupd(dev, offset, 0);
202 static int stmfx_gpio_get_dir_flags(struct udevice *dev, unsigned int offset,
208 if (stmfx_gpio_get_function(dev, offset) == GPIOF_OUTPUT) {
209 dir_flags |= GPIOD_IS_OUT;
210 ret = stmfx_conf_get_type(dev, offset);
214 dir_flags |= GPIOD_OPEN_DRAIN;
215 /* 1 = push-pull (default), open source not supported */
216 ret = stmfx_gpio_get(dev, offset);
220 dir_flags |= GPIOD_IS_OUT_ACTIVE;
222 dir_flags |= GPIOD_IS_IN;
223 ret = stmfx_conf_get_type(dev, offset);
227 ret = stmfx_conf_get_pupd(dev, offset);
231 dir_flags |= GPIOD_PULL_UP;
233 dir_flags |= GPIOD_PULL_DOWN;
241 static int stmfx_gpio_probe(struct udevice *dev)
243 struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
244 struct ofnode_phandle_args args;
247 uc_priv->bank_name = "stmfx";
248 uc_priv->gpio_count = STMFX_MAX_GPIO + STMFX_MAX_AGPIO;
249 if (!dev_read_phandle_with_args(dev, "gpio-ranges",
250 NULL, 3, 0, &args)) {
251 uc_priv->gpio_count = args.args[2];
254 /* enable GPIO function */
255 sys_ctrl = STMFX_REG_SYS_CTRL_GPIO_EN;
256 if (uc_priv->gpio_count > STMFX_MAX_GPIO)
257 sys_ctrl |= STMFX_REG_SYS_CTRL_ALTGPIO_EN;
258 stmfx_write(dev, STMFX_REG_SYS_CTRL, sys_ctrl);
263 static const struct dm_gpio_ops stmfx_gpio_ops = {
264 .set_value = stmfx_gpio_set,
265 .get_value = stmfx_gpio_get,
266 .get_function = stmfx_gpio_get_function,
267 .direction_input = stmfx_gpio_direction_input,
268 .direction_output = stmfx_gpio_direction_output,
269 .set_dir_flags = stmfx_gpio_set_dir_flags,
270 .get_dir_flags = stmfx_gpio_get_dir_flags,
273 U_BOOT_DRIVER(stmfx_gpio) = {
274 .name = "stmfx-gpio",
276 .probe = stmfx_gpio_probe,
277 .ops = &stmfx_gpio_ops,
280 #if CONFIG_IS_ENABLED(PINCONF)
281 static const struct pinconf_param stmfx_pinctrl_conf_params[] = {
282 { "bias-disable", PIN_CONFIG_BIAS_DISABLE, 0 },
283 { "bias-pull-up", PIN_CONFIG_BIAS_PULL_UP, 0 },
284 { "bias-pull-pin-default", PIN_CONFIG_BIAS_PULL_PIN_DEFAULT, 0 },
285 { "bias-pull-down", PIN_CONFIG_BIAS_PULL_DOWN, 0 },
286 { "drive-open-drain", PIN_CONFIG_DRIVE_OPEN_DRAIN, 0 },
287 { "drive-push-pull", PIN_CONFIG_DRIVE_PUSH_PULL, 0 },
288 { "output-high", PIN_CONFIG_OUTPUT, 1 },
289 { "output-low", PIN_CONFIG_OUTPUT, 0 },
292 static int stmfx_pinctrl_conf_set(struct udevice *dev, unsigned int pin,
293 unsigned int param, unsigned int arg)
296 struct stmfx_pinctrl *plat = dev_get_platdata(dev);
298 dir = stmfx_gpio_get_function(plat->gpio, pin);
304 case PIN_CONFIG_BIAS_PULL_PIN_DEFAULT:
305 case PIN_CONFIG_BIAS_DISABLE:
306 case PIN_CONFIG_DRIVE_PUSH_PULL:
307 ret = stmfx_conf_set_type(dev, pin, 0);
309 case PIN_CONFIG_BIAS_PULL_DOWN:
310 ret = stmfx_conf_set_type(dev, pin, 1);
313 ret = stmfx_conf_set_pupd(dev, pin, 0);
315 case PIN_CONFIG_BIAS_PULL_UP:
316 ret = stmfx_conf_set_type(dev, pin, 1);
319 ret = stmfx_conf_set_pupd(dev, pin, 1);
321 case PIN_CONFIG_DRIVE_OPEN_DRAIN:
322 ret = stmfx_conf_set_type(dev, pin, 1);
324 case PIN_CONFIG_OUTPUT:
325 ret = stmfx_gpio_direction_output(plat->gpio, pin, arg);
335 static int stmfx_pinctrl_get_pins_count(struct udevice *dev)
337 struct stmfx_pinctrl *plat = dev_get_platdata(dev);
338 struct gpio_dev_priv *uc_priv;
340 uc_priv = dev_get_uclass_priv(plat->gpio);
342 return uc_priv->gpio_count;
346 * STMFX pins[15:0] are called "gpio[15:0]"
347 * and STMFX pins[23:16] are called "agpio[7:0]"
349 #define MAX_PIN_NAME_LEN 7
350 static char pin_name[MAX_PIN_NAME_LEN];
351 static const char *stmfx_pinctrl_get_pin_name(struct udevice *dev,
352 unsigned int selector)
354 if (selector < STMFX_MAX_GPIO)
355 snprintf(pin_name, MAX_PIN_NAME_LEN, "gpio%u", selector);
357 snprintf(pin_name, MAX_PIN_NAME_LEN, "agpio%u", selector - 16);
361 static const char *stmfx_pinctrl_get_pin_conf(struct udevice *dev,
362 unsigned int pin, int func)
366 type = stmfx_conf_get_type(dev, pin);
370 if (func == GPIOF_OUTPUT) {
372 return "drive-open-drain";
374 return ""; /* default: push-pull*/
377 return ""; /* default: bias-disable*/
379 pupd = stmfx_conf_get_pupd(dev, pin);
384 return "bias-pull-up";
386 return "bias-pull-down";
389 static int stmfx_pinctrl_get_pin_muxing(struct udevice *dev,
390 unsigned int selector,
393 struct stmfx_pinctrl *plat = dev_get_platdata(dev);
396 func = stmfx_gpio_get_function(plat->gpio, selector);
400 snprintf(buf, size, "%s ", func == GPIOF_INPUT ? "input" : "output");
402 strncat(buf, stmfx_pinctrl_get_pin_conf(dev, selector, func), size);
407 static int stmfx_pinctrl_bind(struct udevice *dev)
409 struct stmfx_pinctrl *plat = dev_get_platdata(dev);
411 return device_bind_driver_to_node(dev->parent,
412 "stmfx-gpio", "stmfx-gpio",
413 dev_ofnode(dev), &plat->gpio);
416 static int stmfx_pinctrl_probe(struct udevice *dev)
418 struct stmfx_pinctrl *plat = dev_get_platdata(dev);
420 return device_probe(plat->gpio);
423 const struct pinctrl_ops stmfx_pinctrl_ops = {
424 .get_pins_count = stmfx_pinctrl_get_pins_count,
425 .get_pin_name = stmfx_pinctrl_get_pin_name,
426 .set_state = pinctrl_generic_set_state,
427 .get_pin_muxing = stmfx_pinctrl_get_pin_muxing,
428 #if CONFIG_IS_ENABLED(PINCONF)
429 .pinconf_set = stmfx_pinctrl_conf_set,
430 .pinconf_num_params = ARRAY_SIZE(stmfx_pinctrl_conf_params),
431 .pinconf_params = stmfx_pinctrl_conf_params,
435 static const struct udevice_id stmfx_pinctrl_match[] = {
436 { .compatible = "st,stmfx-0300-pinctrl", },
439 U_BOOT_DRIVER(stmfx_pinctrl) = {
440 .name = "stmfx-pinctrl",
441 .id = UCLASS_PINCTRL,
442 .of_match = of_match_ptr(stmfx_pinctrl_match),
443 .bind = stmfx_pinctrl_bind,
444 .probe = stmfx_pinctrl_probe,
445 .ops = &stmfx_pinctrl_ops,
446 .platdata_auto_alloc_size = sizeof(struct stmfx_pinctrl),
449 static int stmfx_chip_init(struct udevice *dev)
454 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
456 ret = dm_i2c_reg_read(dev, STMFX_REG_CHIP_ID);
458 dev_err(dev, "error reading chip id: %d\n", ret);
463 * Check that ID is the complement of the I2C address:
464 * STMFX I2C address follows the 7-bit format (MSB), that's why
465 * client->addr is shifted.
467 * STMFX_I2C_ADDR| STMFX | Linux
468 * input pin | I2C device address | I2C device address
469 *---------------------------------------------------------
470 * 0 | b: 1000 010x h:0x84 | 0x42
471 * 1 | b: 1000 011x h:0x86 | 0x43
473 if (FIELD_GET(STMFX_REG_CHIP_ID_MASK, ~id) != (chip->chip_addr << 1)) {
474 dev_err(dev, "unknown chip id: %#x\n", id);
478 ret = dm_i2c_read(dev, STMFX_REG_FW_VERSION_MSB,
479 version, sizeof(version));
481 dev_err(dev, "error reading fw version: %d\n", ret);
485 dev_info(dev, "STMFX id: %#x, fw version: %x.%02x\n",
486 id, version[0], version[1]);
488 ret = dm_i2c_reg_read(dev, STMFX_REG_SYS_CTRL);
493 ret = dm_i2c_reg_write(dev, STMFX_REG_SYS_CTRL,
494 ret | STMFX_REG_SYS_CTRL_SWRST);
498 mdelay(STMFX_BOOT_TIME_MS);
503 static int stmfx_probe(struct udevice *dev)
508 ret = device_get_supply_regulator(dev, "vdd-supply", &vdd);
509 if (ret && ret != -ENOENT) {
510 dev_err(dev, "vdd regulator error:%d\n", ret);
514 ret = regulator_set_enable(vdd, true);
516 dev_err(dev, "vdd enable failed: %d\n", ret);
521 return stmfx_chip_init(dev);
524 static const struct udevice_id stmfx_match[] = {
525 { .compatible = "st,stmfx-0300", },
528 U_BOOT_DRIVER(stmfx) = {
530 .id = UCLASS_I2C_GENERIC,
531 .of_match = of_match_ptr(stmfx_match),
532 .probe = stmfx_probe,
533 .bind = dm_scan_fdt_dev,