[linux-2.6-block.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 mcb_device *mdev;
	struct resource *mem;
	spinlock_t lock;
};

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 = &priv->mdev->dev;
	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(&priv->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(&priv->lock);

	return 0;
}

static int men_z127_request(struct gpio_chip *gc, unsigned gpio_pin)
{
	struct men_z127_gpio *priv = gpiochip_get_data(gc);
	u32 od_en;

	if (gpio_pin >= gc->ngpio)
		return -EINVAL;

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

	if (gpiochip_line_is_open_drain(gc, gpio_pin))
		od_en |= BIT(gpio_pin);
	else
		od_en &= ~BIT(gpio_pin);

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

	return 0;
}

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;
	}

	men_z127_gpio->mdev = mdev;
	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_debounce = men_z127_debounce;
	men_z127_gpio->gc.request = men_z127_request;

	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",
		.owner = THIS_MODULE,
	},
	.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;
	38	struct mcb_device *mdev;
	39	struct resource *mem;
	40	spinlock_t lock;
	41	};
	42
	43	static int men_z127_debounce(struct gpio_chip *gc, unsigned gpio,
	44	unsigned debounce)
	45	{
	46	struct men_z127_gpio *priv = gpiochip_get_data(gc);
	47	struct device *dev = &priv->mdev->dev;
	48	unsigned int rnd;
	49	u32 db_en, db_cnt;
	50
	51	if (!MEN_Z127_DB_IN_RANGE(debounce)) {
	52	dev_err(dev, "debounce value %u out of range", debounce);
	53	return -EINVAL;
	54	}
	55
	56	if (debounce > 0) {
	57	/* round up or down depending on MSB-1 */
	58	rnd = fls(debounce) - 1;
	59
	60	if (rnd && (debounce & BIT(rnd - 1)))
	61	debounce = round_up(debounce, MEN_Z127_DB_MIN_US);
	62	else
	63	debounce = round_down(debounce, MEN_Z127_DB_MIN_US);
	64
65	if (debounce > MEN_Z127_DB_MAX_US)
66	debounce = MEN_Z127_DB_MAX_US;
67
68	/* 50us per register unit */
69	debounce /= 50;
70	}
71
72	spin_lock(&priv->lock);
73
74	db_en = readl(priv->reg_base + MEN_Z127_DBER);
75
76	if (debounce == 0) {
77	db_en &= ~BIT(gpio);
78	db_cnt = 0;
79	} else {
80	db_en \|= BIT(gpio);
81	db_cnt = debounce;
82	}
83
84	writel(db_en, priv->reg_base + MEN_Z127_DBER);
85	writel(db_cnt, priv->reg_base + GPIO_TO_DBCNT_REG(gpio));
86
87	spin_unlock(&priv->lock);
88
89	return 0;
90	}
91
92	static int men_z127_request(struct gpio_chip *gc, unsigned gpio_pin)
93	{
94	struct men_z127_gpio *priv = gpiochip_get_data(gc);
95	u32 od_en;
96
97	if (gpio_pin >= gc->ngpio)
98	return -EINVAL;
99
100	spin_lock(&priv->lock);
101	od_en = readl(priv->reg_base + MEN_Z127_ODER);
102
103	if (gpiochip_line_is_open_drain(gc, gpio_pin))
104	od_en \|= BIT(gpio_pin);
105	else
106	od_en &= ~BIT(gpio_pin);
107
108	writel(od_en, priv->reg_base + MEN_Z127_ODER);
109	spin_unlock(&priv->lock);
110
111	return 0;
112	}
113
114	static int men_z127_probe(struct mcb_device *mdev,
115	const struct mcb_device_id *id)
116	{
117	struct men_z127_gpio *men_z127_gpio;
118	struct device *dev = &mdev->dev;
119	int ret;
120
121	men_z127_gpio = devm_kzalloc(dev, sizeof(struct men_z127_gpio),
122	GFP_KERNEL);
123	if (!men_z127_gpio)
124	return -ENOMEM;
125
126	men_z127_gpio->mem = mcb_request_mem(mdev, dev_name(dev));
127	if (IS_ERR(men_z127_gpio->mem)) {
128	dev_err(dev, "failed to request device memory");
129	return PTR_ERR(men_z127_gpio->mem);
130	}
131
132	men_z127_gpio->reg_base = ioremap(men_z127_gpio->mem->start,
133	resource_size(men_z127_gpio->mem));
134	if (men_z127_gpio->reg_base == NULL) {
135	ret = -ENXIO;
136	goto err_release;
137	}
138
139	men_z127_gpio->mdev = mdev;
140	mcb_set_drvdata(mdev, men_z127_gpio);
141
142	ret = bgpio_init(&men_z127_gpio->gc, &mdev->dev, 4,
143	men_z127_gpio->reg_base + MEN_Z127_PSR,
144	men_z127_gpio->reg_base + MEN_Z127_CTRL,
145	NULL,
146	men_z127_gpio->reg_base + MEN_Z127_GPIODR,
147	NULL, 0);
148	if (ret)
149	goto err_unmap;
150
151	men_z127_gpio->gc.set_debounce = men_z127_debounce;
152	men_z127_gpio->gc.request = men_z127_request;
153
154	ret = gpiochip_add_data(&men_z127_gpio->gc, men_z127_gpio);
155	if (ret) {
156	dev_err(dev, "failed to register MEN 16Z127 GPIO controller");
157	goto err_unmap;
158	}
159
160	dev_info(dev, "MEN 16Z127 GPIO driver registered");
161
162	return 0;
163
164	err_unmap:
165	iounmap(men_z127_gpio->reg_base);
166	err_release:
167	mcb_release_mem(men_z127_gpio->mem);
168	return ret;
169	}
170
171	static void men_z127_remove(struct mcb_device *mdev)
172	{
173	struct men_z127_gpio *men_z127_gpio = mcb_get_drvdata(mdev);
174
175	gpiochip_remove(&men_z127_gpio->gc);
176	iounmap(men_z127_gpio->reg_base);
177	mcb_release_mem(men_z127_gpio->mem);
178	}
179
180	static const struct mcb_device_id men_z127_ids[] = {
181	{ .device = 0x7f },
182	{ }
183	};
184	MODULE_DEVICE_TABLE(mcb, men_z127_ids);
185
186	static struct mcb_driver men_z127_driver = {
187	.driver = {
188	.name = "z127-gpio",
189	.owner = THIS_MODULE,
190	},
191	.probe = men_z127_probe,
192	.remove = men_z127_remove,
193	.id_table = men_z127_ids,
194	};
195	module_mcb_driver(men_z127_driver);
196
197	MODULE_AUTHOR("Andreas Werner <andreas.werner@men.de>");
198	MODULE_DESCRIPTION("MEN 16z127 GPIO Controller");
199	MODULE_LICENSE("GPL v2");
200	MODULE_ALIAS("mcb:16z127");