#include <linux/bitmap.h>
#include <linux/bitops.h>
#include <linux/gpio/driver.h>
#include <linux/gpio/regmap.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/mfd/rohm-bd73800.h>
#define BD73800_GPIO_MAX_PINS 4
struct bd73800_gpio {
struct device *dev;
struct regmap *regmap;
DECLARE_BITMAP(valid_mask, BD73800_GPIO_MAX_PINS);
DECLARE_BITMAP(output_mask, BD73800_GPIO_MAX_PINS);
};
static const char * const bd73800_gpio_properties[BD73800_GPIO_MAX_PINS] = {
"rohm,pin-gpio1",
"rohm,pin-clkout",
"rohm,pin-fault_b",
"rohm,pin-exten"
};
static int bd73800_gpio_get_pins(struct bd73800_gpio *data)
{
struct device *parent = data->dev->parent;
const char *val;
int i, ret;
for (i = 0; i < BD73800_GPIO_MAX_PINS; i++) {
ret = device_property_read_string(parent,
bd73800_gpio_properties[i],
&val);
if (ret) {
if (ret == -EINVAL)
continue;
return dev_err_probe(data->dev, ret,
"pin %d (%s), bad configuration\n", i,
bd73800_gpio_properties[i]);
}
if (!strcmp(val, "gpi")) {
__set_bit(i, data->valid_mask);
} else if (!strcmp(val, "gpo")) {
__set_bit(i, data->valid_mask);
__set_bit(i, data->output_mask);
} else {
dev_warn(data->dev,
"pin %d (%s), unknown value '%s' ignored\n", i,
bd73800_gpio_properties[i], val);
}
}
return 0;
}
static int bd73800_gpio_init_valid_mask(struct gpio_chip *gc,
unsigned long *valid_mask,
unsigned int ngpios)
{
struct gpio_regmap *gpio = gpiochip_get_data(gc);
struct bd73800_gpio *data = gpio_regmap_get_drvdata(gpio);
bitmap_copy(valid_mask, data->valid_mask, ngpios);
return 0;
}
static int bd73800_gpio_reg_mask_xlate(struct gpio_regmap *gpio,
enum gpio_regmap_operation op,
unsigned int base, unsigned int offset,
unsigned int *reg, unsigned int *mask)
{
struct bd73800_gpio *data = gpio_regmap_get_drvdata(gpio);
bool is_output = test_bit(offset, data->output_mask);
if (is_output)
*reg = BD73800_REG_GPO_OUT;
else
*reg = base;
*mask = BIT(offset);
return 0;
}
static int gpo_bd73800_probe(struct platform_device *pdev)
{
struct gpio_regmap_config config = { };
struct bd73800_gpio *data;
struct device *parent, *dev;
int ret;
dev = &pdev->dev;
parent = dev->parent;
data = devm_kzalloc_obj(dev, *data);
if (!data)
return -ENOMEM;
data->dev = dev;
data->regmap = dev_get_regmap(parent, NULL);
if (!data->regmap)
return dev_err_probe(dev, -ENODEV, "no parent regmap\n");
ret = bd73800_gpio_get_pins(data);
if (ret)
return ret;
if (bitmap_empty(data->valid_mask, BD73800_GPIO_MAX_PINS)) {
dev_dbg(dev, "no GPIO pins\n");
return -ENODEV;
}
config.parent = parent;
config.regmap = data->regmap;
config.label = "bd73800";
config.ngpio = BD73800_GPIO_MAX_PINS;
config.reg_dat_base = BD73800_REG_INT_5_SRC;
config.reg_set_base = BD73800_REG_GPO_OUT;
config.reg_mask_xlate = bd73800_gpio_reg_mask_xlate;
config.init_valid_mask = bd73800_gpio_init_valid_mask;
config.fixed_direction_mask = data->valid_mask;
config.fixed_direction_output = data->output_mask;
config.drvdata = data;
return PTR_ERR_OR_ZERO(devm_gpio_regmap_register(dev, &config));
}
static const struct platform_device_id bd73800_gpio_id[] = {
{ "bd73800-gpio" },
{ },
};
MODULE_DEVICE_TABLE(platform, bd73800_gpio_id);
static struct platform_driver gpo_bd73800_driver = {
.driver = {
.name = "bd73800-gpio",
.probe_type = PROBE_PREFER_ASYNCHRONOUS,
},
.probe = gpo_bd73800_probe,
.id_table = bd73800_gpio_id,
};
module_platform_driver(gpo_bd73800_driver);
MODULE_AUTHOR("Matti Vaittinen <mazziesaccount@gmail.com>");
MODULE_DESCRIPTION("GPIO interface for BD73800");
MODULE_LICENSE("GPL"