[mirror_ubuntu-bionic-kernel.git] / drivers / gpio / gpio-menz127.c

/*
 * MEN 16Z127 GPIO driver
 *
 * Copyright (C) 2016 MEN Mikroelektronik GmbH (www.men.de)
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; version 2 of the License.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/io.h>
#include <linux/err.h>
#include <linux/mcb.h>
#include <linux/bitops.h>
#include <linux/gpio/driver.h>

#define MEN_Z127_CTRL	0x00
#define MEN_Z127_PSR	0x04
#define MEN_Z127_IRQR	0x08
#define MEN_Z127_GPIODR	0x0c
#define MEN_Z127_IER1	0x10
#define MEN_Z127_IER2	0x14
#define MEN_Z127_DBER	0x18
#define MEN_Z127_ODER	0x1C
#define GPIO_TO_DBCNT_REG(gpio)	((gpio * 4) + 0x80)

#define MEN_Z127_DB_MIN_US	50
/* 16 bit compare register. Each bit represents 50us */
#define MEN_Z127_DB_MAX_US	(0xffff * MEN_Z127_DB_MIN_US)
#define MEN_Z127_DB_IN_RANGE(db)	((db >= MEN_Z127_DB_MIN_US) && \
					 (db <= MEN_Z127_DB_MAX_US))

struct men_z127_gpio {
	struct gpio_chip gc;
	void __iomem *reg_base;
	struct resource *mem;
};

static int men_z127_debounce(struct gpio_chip *gc, unsigned gpio,
			     unsigned debounce)
{
	struct men_z127_gpio *priv = gpiochip_get_data(gc);
	struct device *dev = gc->parent;
	unsigned int rnd;
	u32 db_en, db_cnt;

	if (!MEN_Z127_DB_IN_RANGE(debounce)) {
		dev_err(dev, "debounce value %u out of range", debounce);
		return -EINVAL;
	}

	if (debounce > 0) {
		/* round up or down depending on MSB-1 */
		rnd = fls(debounce) - 1;

		if (rnd && (debounce & BIT(rnd - 1)))
			debounce = round_up(debounce, MEN_Z127_DB_MIN_US);
		else
			debounce = round_down(debounce, MEN_Z127_DB_MIN_US);

		if (debounce > MEN_Z127_DB_MAX_US)
			debounce = MEN_Z127_DB_MAX_US;

		/* 50us per register unit */
		debounce /= 50;
	}

	spin_lock(&gc->bgpio_lock);

	db_en = readl(priv->reg_base + MEN_Z127_DBER);

	if (debounce == 0) {
		db_en &= ~BIT(gpio);
		db_cnt = 0;
	} else {
		db_en |= BIT(gpio);
		db_cnt = debounce;
	}

	writel(db_en, priv->reg_base + MEN_Z127_DBER);
	writel(db_cnt, priv->reg_base + GPIO_TO_DBCNT_REG(gpio));

	spin_unlock(&gc->bgpio_lock);

	return 0;
}

static int men_z127_set_single_ended(struct gpio_chip *gc,
				     unsigned offset,
				     enum pin_config_param param)
{
	struct men_z127_gpio *priv = gpiochip_get_data(gc);
	u32 od_en;

	spin_lock(&gc->bgpio_lock);
	od_en = readl(priv->reg_base + MEN_Z127_ODER);

	if (param == PIN_CONFIG_DRIVE_OPEN_DRAIN)
		od_en |= BIT(offset);
	else
		/* Implicitly PIN_CONFIG_DRIVE_PUSH_PULL */
		od_en &= ~BIT(offset);

	writel(od_en, priv->reg_base + MEN_Z127_ODER);
	spin_unlock(&gc->bgpio_lock);

	return 0;
}

static int men_z127_set_config(struct gpio_chip *gc, unsigned offset,
			       unsigned long config)
{
	enum pin_config_param param = pinconf_to_config_param(config);

	switch (param) {
	case PIN_CONFIG_DRIVE_OPEN_DRAIN:
	case PIN_CONFIG_DRIVE_PUSH_PULL:
		return men_z127_set_single_ended(gc, offset, param);

	case PIN_CONFIG_INPUT_DEBOUNCE:
		return men_z127_debounce(gc, offset,
			pinconf_to_config_argument(config));

	default:
		break;
	}

	return -ENOTSUPP;
}

static int men_z127_probe(struct mcb_device *mdev,
			  const struct mcb_device_id *id)
{
	struct men_z127_gpio *men_z127_gpio;
	struct device *dev = &mdev->dev;
	int ret;

	men_z127_gpio = devm_kzalloc(dev, sizeof(struct men_z127_gpio),
				     GFP_KERNEL);
	if (!men_z127_gpio)
		return -ENOMEM;

	men_z127_gpio->mem = mcb_request_mem(mdev, dev_name(dev));
	if (IS_ERR(men_z127_gpio->mem)) {
		dev_err(dev, "failed to request device memory");
		return PTR_ERR(men_z127_gpio->mem);
	}

	men_z127_gpio->reg_base = ioremap(men_z127_gpio->mem->start,
					  resource_size(men_z127_gpio->mem));
	if (men_z127_gpio->reg_base == NULL) {
		ret = -ENXIO;
		goto err_release;
	}

	mcb_set_drvdata(mdev, men_z127_gpio);

	ret = bgpio_init(&men_z127_gpio->gc, &mdev->dev, 4,
			 men_z127_gpio->reg_base + MEN_Z127_PSR,
			 men_z127_gpio->reg_base + MEN_Z127_CTRL,
			 NULL,
			 men_z127_gpio->reg_base + MEN_Z127_GPIODR,
			 NULL, 0);
	if (ret)
		goto err_unmap;

	men_z127_gpio->gc.set_config = men_z127_set_config;

	ret = gpiochip_add_data(&men_z127_gpio->gc, men_z127_gpio);
	if (ret) {
		dev_err(dev, "failed to register MEN 16Z127 GPIO controller");
		goto err_unmap;
	}

	dev_info(dev, "MEN 16Z127 GPIO driver registered");

	return 0;

err_unmap:
	iounmap(men_z127_gpio->reg_base);
err_release:
	mcb_release_mem(men_z127_gpio->mem);
	return ret;
}

static void men_z127_remove(struct mcb_device *mdev)
{
	struct men_z127_gpio *men_z127_gpio = mcb_get_drvdata(mdev);

	gpiochip_remove(&men_z127_gpio->gc);
	iounmap(men_z127_gpio->reg_base);
	mcb_release_mem(men_z127_gpio->mem);
}

static const struct mcb_device_id men_z127_ids[] = {
	{ .device = 0x7f },
	{ }
};
MODULE_DEVICE_TABLE(mcb, men_z127_ids);

static struct mcb_driver men_z127_driver = {
	.driver = {
		.name = "z127-gpio",
	},
	.probe = men_z127_probe,
	.remove = men_z127_remove,
	.id_table = men_z127_ids,
};
module_mcb_driver(men_z127_driver);

MODULE_AUTHOR("Andreas Werner <andreas.werner@men.de>");
MODULE_DESCRIPTION("MEN 16z127 GPIO Controller");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("mcb:16z127");
Commit	Line	Data
f436bc27 AW	1	/*
	2	* MEN 16Z127 GPIO driver
	3	*
	4	* Copyright (C) 2016 MEN Mikroelektronik GmbH (www.men.de)
	5	*
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the Free
	8	* Software Foundation; version 2 of the License.
	9	*/
	10
	11	#include <linux/kernel.h>
	12	#include <linux/module.h>
	13	#include <linux/io.h>
	14	#include <linux/err.h>
	15	#include <linux/mcb.h>
	16	#include <linux/bitops.h>
	17	#include <linux/gpio/driver.h>
	18
	19	#define MEN_Z127_CTRL 0x00
	20	#define MEN_Z127_PSR 0x04
	21	#define MEN_Z127_IRQR 0x08
	22	#define MEN_Z127_GPIODR 0x0c
	23	#define MEN_Z127_IER1 0x10
	24	#define MEN_Z127_IER2 0x14
	25	#define MEN_Z127_DBER 0x18
	26	#define MEN_Z127_ODER 0x1C
	27	#define GPIO_TO_DBCNT_REG(gpio) ((gpio * 4) + 0x80)
	28
	29	#define MEN_Z127_DB_MIN_US 50
	30	/* 16 bit compare register. Each bit represents 50us */
	31	#define MEN_Z127_DB_MAX_US (0xffff * MEN_Z127_DB_MIN_US)
	32	#define MEN_Z127_DB_IN_RANGE(db) ((db >= MEN_Z127_DB_MIN_US) && \
	33	(db <= MEN_Z127_DB_MAX_US))
	34
	35	struct men_z127_gpio {
	36	struct gpio_chip gc;
	37	void __iomem *reg_base;
f436bc27	38	struct resource *mem;
f436bc27 AW	39	};
	40
	41	static int men_z127_debounce(struct gpio_chip *gc, unsigned gpio,
	42	unsigned debounce)
	43	{
	44	struct men_z127_gpio *priv = gpiochip_get_data(gc);
86d3f367	45	struct device *dev = gc->parent;
f436bc27 AW	46	unsigned int rnd;
	47	u32 db_en, db_cnt;
	48
	49	if (!MEN_Z127_DB_IN_RANGE(debounce)) {
	50	dev_err(dev, "debounce value %u out of range", debounce);
	51	return -EINVAL;
	52	}
	53
	54	if (debounce > 0) {
	55	/* round up or down depending on MSB-1 */
	56	rnd = fls(debounce) - 1;
	57
	58	if (rnd && (debounce & BIT(rnd - 1)))
	59	debounce = round_up(debounce, MEN_Z127_DB_MIN_US);
	60	else
	61	debounce = round_down(debounce, MEN_Z127_DB_MIN_US);
	62
	63	if (debounce > MEN_Z127_DB_MAX_US)
	64	debounce = MEN_Z127_DB_MAX_US;
	65
	66	/* 50us per register unit */
	67	debounce /= 50;
	68	}
	69
fd975a7b	70	spin_lock(&gc->bgpio_lock);
f436bc27 AW	71
	72	db_en = readl(priv->reg_base + MEN_Z127_DBER);
	73
	74	if (debounce == 0) {
	75	db_en &= ~BIT(gpio);
	76	db_cnt = 0;
	77	} else {
	78	db_en \|= BIT(gpio);
	79	db_cnt = debounce;
	80	}
	81
	82	writel(db_en, priv->reg_base + MEN_Z127_DBER);
	83	writel(db_cnt, priv->reg_base + GPIO_TO_DBCNT_REG(gpio));
	84
fd975a7b	85	spin_unlock(&gc->bgpio_lock);
f436bc27 AW	86
	87	return 0;
	88	}
	89
811a1882 LW	90	static int men_z127_set_single_ended(struct gpio_chip *gc,
811a1882 LW	91	unsigned offset,
2956b5d9	92	enum pin_config_param param)
f436bc27 AW	93	{
	94	struct men_z127_gpio *priv = gpiochip_get_data(gc);
	95	u32 od_en;
	96
fd975a7b	97	spin_lock(&gc->bgpio_lock);
f436bc27 AW	98	od_en = readl(priv->reg_base + MEN_Z127_ODER);
f436bc27 AW	99
2956b5d9	100	if (param == PIN_CONFIG_DRIVE_OPEN_DRAIN)
811a1882	101	od_en \|= BIT(offset);
f436bc27	102	else
2956b5d9	103	/* Implicitly PIN_CONFIG_DRIVE_PUSH_PULL */
811a1882	104	od_en &= ~BIT(offset);
f436bc27 AW	105
f436bc27 AW	106	writel(od_en, priv->reg_base + MEN_Z127_ODER);
fd975a7b	107	spin_unlock(&gc->bgpio_lock);
f436bc27 AW	108
	109	return 0;
	110	}
	111
2956b5d9 MW	112	static int men_z127_set_config(struct gpio_chip *gc, unsigned offset,
	113	unsigned long config)
	114	{
	115	enum pin_config_param param = pinconf_to_config_param(config);
	116
	117	switch (param) {
	118	case PIN_CONFIG_DRIVE_OPEN_DRAIN:
	119	case PIN_CONFIG_DRIVE_PUSH_PULL:
	120	return men_z127_set_single_ended(gc, offset, param);
	121
	122	case PIN_CONFIG_INPUT_DEBOUNCE:
	123	return men_z127_debounce(gc, offset,
	124	pinconf_to_config_argument(config));
	125
	126	default:
	127	break;
	128	}
	129
	130	return -ENOTSUPP;
	131	}
	132
f436bc27 AW	133	static int men_z127_probe(struct mcb_device *mdev,
	134	const struct mcb_device_id *id)
	135	{
	136	struct men_z127_gpio *men_z127_gpio;
	137	struct device *dev = &mdev->dev;
	138	int ret;
	139
	140	men_z127_gpio = devm_kzalloc(dev, sizeof(struct men_z127_gpio),
	141	GFP_KERNEL);
	142	if (!men_z127_gpio)
	143	return -ENOMEM;
	144
	145	men_z127_gpio->mem = mcb_request_mem(mdev, dev_name(dev));
	146	if (IS_ERR(men_z127_gpio->mem)) {
	147	dev_err(dev, "failed to request device memory");
	148	return PTR_ERR(men_z127_gpio->mem);
	149	}
	150
	151	men_z127_gpio->reg_base = ioremap(men_z127_gpio->mem->start,
	152	resource_size(men_z127_gpio->mem));
	153	if (men_z127_gpio->reg_base == NULL) {
	154	ret = -ENXIO;
	155	goto err_release;
	156	}
	157
f436bc27 AW	158	mcb_set_drvdata(mdev, men_z127_gpio);
	159
	160	ret = bgpio_init(&men_z127_gpio->gc, &mdev->dev, 4,
	161	men_z127_gpio->reg_base + MEN_Z127_PSR,
	162	men_z127_gpio->reg_base + MEN_Z127_CTRL,
	163	NULL,
	164	men_z127_gpio->reg_base + MEN_Z127_GPIODR,
	165	NULL, 0);
	166	if (ret)
	167	goto err_unmap;
	168
2956b5d9	169	men_z127_gpio->gc.set_config = men_z127_set_config;
f436bc27 AW	170
	171	ret = gpiochip_add_data(&men_z127_gpio->gc, men_z127_gpio);
	172	if (ret) {
	173	dev_err(dev, "failed to register MEN 16Z127 GPIO controller");
	174	goto err_unmap;
	175	}
	176
	177	dev_info(dev, "MEN 16Z127 GPIO driver registered");
	178
	179	return 0;
	180
	181	err_unmap:
	182	iounmap(men_z127_gpio->reg_base);
	183	err_release:
	184	mcb_release_mem(men_z127_gpio->mem);
	185	return ret;
	186	}
	187
	188	static void men_z127_remove(struct mcb_device *mdev)
	189	{
	190	struct men_z127_gpio *men_z127_gpio = mcb_get_drvdata(mdev);
	191
	192	gpiochip_remove(&men_z127_gpio->gc);
	193	iounmap(men_z127_gpio->reg_base);
	194	mcb_release_mem(men_z127_gpio->mem);
	195	}
	196
	197	static const struct mcb_device_id men_z127_ids[] = {
	198	{ .device = 0x7f },
	199	{ }
	200	};
	201	MODULE_DEVICE_TABLE(mcb, men_z127_ids);
	202
	203	static struct mcb_driver men_z127_driver = {
	204	.driver = {
	205	.name = "z127-gpio",
f436bc27 AW	206	},
	207	.probe = men_z127_probe,
	208	.remove = men_z127_remove,
	209	.id_table = men_z127_ids,
	210	};
	211	module_mcb_driver(men_z127_driver);
	212
	213	MODULE_AUTHOR("Andreas Werner <andreas.werner@men.de>");
	214	MODULE_DESCRIPTION("MEN 16z127 GPIO Controller");
	215	MODULE_LICENSE("GPL v2");
	216	MODULE_ALIAS("mcb:16z127");