[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / gpio / gpio-ts5500.c

/*
 * Digital I/O driver for Technologic Systems TS-5500
 *
 * Copyright (c) 2012 Savoir-faire Linux Inc.
 *	Vivien Didelot <vivien.didelot@savoirfairelinux.com>
 *
 * Technologic Systems platforms have pin blocks, exposing several Digital
 * Input/Output lines (DIO). This driver aims to support single pin blocks.
 * In that sense, the support is not limited to the TS-5500 blocks.
 * Actually, the following platforms have DIO support:
 *
 * TS-5500:
 *   Documentation: http://wiki.embeddedarm.com/wiki/TS-5500
 *   Blocks: DIO1, DIO2 and LCD port.
 *
 * TS-5600:
 *   Documentation: http://wiki.embeddedarm.com/wiki/TS-5600
 *   Blocks: LCD port (identical to TS-5500 LCD).
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/bitops.h>
#include <linux/gpio.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/platform_data/gpio-ts5500.h>
#include <linux/platform_device.h>
#include <linux/slab.h>

/* List of supported Technologic Systems platforms DIO blocks */
enum ts5500_blocks { TS5500_DIO1, TS5500_DIO2, TS5500_LCD, TS5600_LCD };

struct ts5500_priv {
	const struct ts5500_dio *pinout;
	struct gpio_chip gpio_chip;
	spinlock_t lock;
	bool strap;
	u8 hwirq;
};

/*
 * Hex 7D is used to control several blocks (e.g. DIO2 and LCD port).
 * This flag ensures that the region has been requested by this driver.
 */
static bool hex7d_reserved;

/*
 * This structure is used to describe capabilities of DIO lines,
 * such as available directions and connected interrupt (if any).
 */
struct ts5500_dio {
	const u8 value_addr;
	const u8 value_mask;
	const u8 control_addr;
	const u8 control_mask;
	const bool no_input;
	const bool no_output;
	const u8 irq;
};

#define TS5500_DIO_IN_OUT(vaddr, vbit, caddr, cbit)	\
	{						\
		.value_addr = vaddr,			\
		.value_mask = BIT(vbit),		\
		.control_addr = caddr,			\
		.control_mask = BIT(cbit),		\
	}

#define TS5500_DIO_IN(addr, bit)		\
	{					\
		.value_addr = addr,		\
		.value_mask = BIT(bit),		\
		.no_output = true,		\
	}

#define TS5500_DIO_IN_IRQ(addr, bit, _irq)	\
	{					\
		.value_addr = addr,		\
		.value_mask = BIT(bit),		\
		.no_output = true,		\
		.irq = _irq,			\
	}

#define TS5500_DIO_OUT(addr, bit)		\
	{					\
		.value_addr = addr,		\
		.value_mask = BIT(bit),		\
		.no_input = true,		\
	}

/*
 * Input/Output DIO lines are programmed in groups of 4. Their values are
 * available through 4 consecutive bits in a value port, whereas the direction
 * of these 4 lines is driven by only 1 bit in a control port.
 */
#define TS5500_DIO_GROUP(vaddr, vbitfrom, caddr, cbit)		\
	TS5500_DIO_IN_OUT(vaddr, vbitfrom + 0, caddr, cbit),	\
	TS5500_DIO_IN_OUT(vaddr, vbitfrom + 1, caddr, cbit),	\
	TS5500_DIO_IN_OUT(vaddr, vbitfrom + 2, caddr, cbit),	\
	TS5500_DIO_IN_OUT(vaddr, vbitfrom + 3, caddr, cbit)

/*
 * TS-5500 DIO1 block
 *
 *  value    control  dir    hw
 *  addr bit addr bit in out irq name     pin offset
 *
 *  0x7b  0  0x7a  0  x   x      DIO1_0   1   0
 *  0x7b  1  0x7a  0  x   x      DIO1_1   3   1
 *  0x7b  2  0x7a  0  x   x      DIO1_2   5   2
 *  0x7b  3  0x7a  0  x   x      DIO1_3   7   3
 *  0x7b  4  0x7a  1  x   x      DIO1_4   9   4
 *  0x7b  5  0x7a  1  x   x      DIO1_5   11  5
 *  0x7b  6  0x7a  1  x   x      DIO1_6   13  6
 *  0x7b  7  0x7a  1  x   x      DIO1_7   15  7
 *  0x7c  0  0x7a  5  x   x      DIO1_8   4   8
 *  0x7c  1  0x7a  5  x   x      DIO1_9   6   9
 *  0x7c  2  0x7a  5  x   x      DIO1_10  8   10
 *  0x7c  3  0x7a  5  x   x      DIO1_11  10  11
 *  0x7c  4           x          DIO1_12  12  12
 *  0x7c  5           x      7   DIO1_13  14  13
 */
static const struct ts5500_dio ts5500_dio1[] = {
	TS5500_DIO_GROUP(0x7b, 0, 0x7a, 0),
	TS5500_DIO_GROUP(0x7b, 4, 0x7a, 1),
	TS5500_DIO_GROUP(0x7c, 0, 0x7a, 5),
	TS5500_DIO_IN(0x7c, 4),
	TS5500_DIO_IN_IRQ(0x7c, 5, 7),
};

/*
 * TS-5500 DIO2 block
 *
 *  value    control  dir    hw
 *  addr bit addr bit in out irq name     pin offset
 *
 *  0x7e  0  0x7d  0  x   x      DIO2_0   1   0
 *  0x7e  1  0x7d  0  x   x      DIO2_1   3   1
 *  0x7e  2  0x7d  0  x   x      DIO2_2   5   2
 *  0x7e  3  0x7d  0  x   x      DIO2_3   7   3
 *  0x7e  4  0x7d  1  x   x      DIO2_4   9   4
 *  0x7e  5  0x7d  1  x   x      DIO2_5   11  5
 *  0x7e  6  0x7d  1  x   x      DIO2_6   13  6
 *  0x7e  7  0x7d  1  x   x      DIO2_7   15  7
 *  0x7f  0  0x7d  5  x   x      DIO2_8   4   8
 *  0x7f  1  0x7d  5  x   x      DIO2_9   6   9
 *  0x7f  2  0x7d  5  x   x      DIO2_10  8   10
 *  0x7f  3  0x7d  5  x   x      DIO2_11  10  11
 *  0x7f  4           x      6   DIO2_13  14  12
 */
static const struct ts5500_dio ts5500_dio2[] = {
	TS5500_DIO_GROUP(0x7e, 0, 0x7d, 0),
	TS5500_DIO_GROUP(0x7e, 4, 0x7d, 1),
	TS5500_DIO_GROUP(0x7f, 0, 0x7d, 5),
	TS5500_DIO_IN_IRQ(0x7f, 4, 6),
};

/*
 * TS-5500 LCD port used as DIO block
 * TS-5600 LCD port is identical
 *
 *  value    control  dir    hw
 *  addr bit addr bit in out irq name    pin offset
 *
 *  0x72  0  0x7d  2  x   x      LCD_0   8   0
 *  0x72  1  0x7d  2  x   x      LCD_1   7   1
 *  0x72  2  0x7d  2  x   x      LCD_2   10  2
 *  0x72  3  0x7d  2  x   x      LCD_3   9   3
 *  0x72  4  0x7d  3  x   x      LCD_4   12  4
 *  0x72  5  0x7d  3  x   x      LCD_5   11  5
 *  0x72  6  0x7d  3  x   x      LCD_6   14  6
 *  0x72  7  0x7d  3  x   x      LCD_7   13  7
 *  0x73  0               x      LCD_EN  5   8
 *  0x73  6           x          LCD_WR  6   9
 *  0x73  7           x      1   LCD_RS  3   10
 */
static const struct ts5500_dio ts5500_lcd[] = {
	TS5500_DIO_GROUP(0x72, 0, 0x7d, 2),
	TS5500_DIO_GROUP(0x72, 4, 0x7d, 3),
	TS5500_DIO_OUT(0x73, 0),
	TS5500_DIO_IN(0x73, 6),
	TS5500_DIO_IN_IRQ(0x73, 7, 1),
};

static inline struct ts5500_priv *ts5500_gc_to_priv(struct gpio_chip *chip)
{
	return container_of(chip, struct ts5500_priv, gpio_chip);
}

static inline void ts5500_set_mask(u8 mask, u8 addr)
{
	u8 val = inb(addr);
	val |= mask;
	outb(val, addr);
}

static inline void ts5500_clear_mask(u8 mask, u8 addr)
{
	u8 val = inb(addr);
	val &= ~mask;
	outb(val, addr);
}

static int ts5500_gpio_input(struct gpio_chip *chip, unsigned offset)
{
	struct ts5500_priv *priv = ts5500_gc_to_priv(chip);
	const struct ts5500_dio line = priv->pinout[offset];
	unsigned long flags;

	if (line.no_input)
		return -ENXIO;

	if (line.no_output)
		return 0;

	spin_lock_irqsave(&priv->lock, flags);
	ts5500_clear_mask(line.control_mask, line.control_addr);
	spin_unlock_irqrestore(&priv->lock, flags);

	return 0;
}

static int ts5500_gpio_get(struct gpio_chip *chip, unsigned offset)
{
	struct ts5500_priv *priv = ts5500_gc_to_priv(chip);
	const struct ts5500_dio line = priv->pinout[offset];

	return !!(inb(line.value_addr) & line.value_mask);
}

static int ts5500_gpio_output(struct gpio_chip *chip, unsigned offset, int val)
{
	struct ts5500_priv *priv = ts5500_gc_to_priv(chip);
	const struct ts5500_dio line = priv->pinout[offset];
	unsigned long flags;

	if (line.no_output)
		return -ENXIO;

	spin_lock_irqsave(&priv->lock, flags);
	if (!line.no_input)
		ts5500_set_mask(line.control_mask, line.control_addr);

	if (val)
		ts5500_set_mask(line.value_mask, line.value_addr);
	else
		ts5500_clear_mask(line.value_mask, line.value_addr);
	spin_unlock_irqrestore(&priv->lock, flags);

	return 0;
}

static void ts5500_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
{
	struct ts5500_priv *priv = ts5500_gc_to_priv(chip);
	const struct ts5500_dio line = priv->pinout[offset];
	unsigned long flags;

	spin_lock_irqsave(&priv->lock, flags);
	if (val)
		ts5500_set_mask(line.value_mask, line.value_addr);
	else
		ts5500_clear_mask(line.value_mask, line.value_addr);
	spin_unlock_irqrestore(&priv->lock, flags);
}

static int ts5500_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
{
	struct ts5500_priv *priv = ts5500_gc_to_priv(chip);
	const struct ts5500_dio *block = priv->pinout;
	const struct ts5500_dio line = block[offset];

	/* Only one pin is connected to an interrupt */
	if (line.irq)
		return line.irq;

	/* As this pin is input-only, we may strap it to another in/out pin */
	if (priv->strap)
		return priv->hwirq;

	return -ENXIO;
}

static int ts5500_enable_irq(struct ts5500_priv *priv)
{
	int ret = 0;
	unsigned long flags;

	spin_lock_irqsave(&priv->lock, flags);
	if (priv->hwirq == 7)
		ts5500_set_mask(BIT(7), 0x7a); /* DIO1_13 on IRQ7 */
	else if (priv->hwirq == 6)
		ts5500_set_mask(BIT(7), 0x7d); /* DIO2_13 on IRQ6 */
	else if (priv->hwirq == 1)
		ts5500_set_mask(BIT(6), 0x7d); /* LCD_RS on IRQ1 */
	else
		ret = -EINVAL;
	spin_unlock_irqrestore(&priv->lock, flags);

	return ret;
}

static void ts5500_disable_irq(struct ts5500_priv *priv)
{
	unsigned long flags;

	spin_lock_irqsave(&priv->lock, flags);
	if (priv->hwirq == 7)
		ts5500_clear_mask(BIT(7), 0x7a); /* DIO1_13 on IRQ7 */
	else if (priv->hwirq == 6)
		ts5500_clear_mask(BIT(7), 0x7d); /* DIO2_13 on IRQ6 */
	else if (priv->hwirq == 1)
		ts5500_clear_mask(BIT(6), 0x7d); /* LCD_RS on IRQ1 */
	else
		dev_err(priv->gpio_chip.dev, "invalid hwirq %d\n", priv->hwirq);
	spin_unlock_irqrestore(&priv->lock, flags);
}

static int ts5500_dio_probe(struct platform_device *pdev)
{
	enum ts5500_blocks block = platform_get_device_id(pdev)->driver_data;
	struct ts5500_dio_platform_data *pdata = pdev->dev.platform_data;
	struct device *dev = &pdev->dev;
	const char *name = dev_name(dev);
	struct ts5500_priv *priv;
	struct resource *res;
	unsigned long flags;
	int ret;

	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	if (!res) {
		dev_err(dev, "missing IRQ resource\n");
		return -EINVAL;
	}

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

	platform_set_drvdata(pdev, priv);
	priv->hwirq = res->start;
	spin_lock_init(&priv->lock);

	priv->gpio_chip.owner = THIS_MODULE;
	priv->gpio_chip.label = name;
	priv->gpio_chip.dev = dev;
	priv->gpio_chip.direction_input = ts5500_gpio_input;
	priv->gpio_chip.direction_output = ts5500_gpio_output;
	priv->gpio_chip.get = ts5500_gpio_get;
	priv->gpio_chip.set = ts5500_gpio_set;
	priv->gpio_chip.to_irq = ts5500_gpio_to_irq;
	priv->gpio_chip.base = -1;
	if (pdata) {
		priv->gpio_chip.base = pdata->base;
		priv->strap = pdata->strap;
	}

	switch (block) {
	case TS5500_DIO1:
		priv->pinout = ts5500_dio1;
		priv->gpio_chip.ngpio = ARRAY_SIZE(ts5500_dio1);

		if (!devm_request_region(dev, 0x7a, 3, name)) {
			dev_err(dev, "failed to request %s ports\n", name);
			return -EBUSY;
		}
		break;
	case TS5500_DIO2:
		priv->pinout = ts5500_dio2;
		priv->gpio_chip.ngpio = ARRAY_SIZE(ts5500_dio2);

		if (!devm_request_region(dev, 0x7e, 2, name)) {
			dev_err(dev, "failed to request %s ports\n", name);
			return -EBUSY;
		}

		if (hex7d_reserved)
			break;

		if (!devm_request_region(dev, 0x7d, 1, name)) {
			dev_err(dev, "failed to request %s 7D\n", name);
			return -EBUSY;
		}

		hex7d_reserved = true;
		break;
	case TS5500_LCD:
	case TS5600_LCD:
		priv->pinout = ts5500_lcd;
		priv->gpio_chip.ngpio = ARRAY_SIZE(ts5500_lcd);

		if (!devm_request_region(dev, 0x72, 2, name)) {
			dev_err(dev, "failed to request %s ports\n", name);
			return -EBUSY;
		}

		if (!hex7d_reserved) {
			if (!devm_request_region(dev, 0x7d, 1, name)) {
				dev_err(dev, "failed to request %s 7D\n", name);
				return -EBUSY;
			}

			hex7d_reserved = true;
		}

		/* Ensure usage of LCD port as DIO */
		spin_lock_irqsave(&priv->lock, flags);
		ts5500_clear_mask(BIT(4), 0x7d);
		spin_unlock_irqrestore(&priv->lock, flags);
		break;
	}

	ret = gpiochip_add(&priv->gpio_chip);
	if (ret) {
		dev_err(dev, "failed to register the gpio chip\n");
		return ret;
	}

	ret = ts5500_enable_irq(priv);
	if (ret) {
		dev_err(dev, "invalid interrupt %d\n", priv->hwirq);
		goto cleanup;
	}

	return 0;
cleanup:
	if (gpiochip_remove(&priv->gpio_chip))
		dev_err(dev, "failed to remove gpio chip\n");
	return ret;
}

static int ts5500_dio_remove(struct platform_device *pdev)
{
	struct ts5500_priv *priv = platform_get_drvdata(pdev);

	ts5500_disable_irq(priv);
	return gpiochip_remove(&priv->gpio_chip);
}

static struct platform_device_id ts5500_dio_ids[] = {
	{ "ts5500-dio1", TS5500_DIO1 },
	{ "ts5500-dio2", TS5500_DIO2 },
	{ "ts5500-dio-lcd", TS5500_LCD },
	{ "ts5600-dio-lcd", TS5600_LCD },
	{ }
};
MODULE_DEVICE_TABLE(platform, ts5500_dio_ids);

static struct platform_driver ts5500_dio_driver = {
	.driver = {
		.name = "ts5500-dio",
		.owner = THIS_MODULE,
	},
	.probe = ts5500_dio_probe,
	.remove = ts5500_dio_remove,
	.id_table = ts5500_dio_ids,
};

module_platform_driver(ts5500_dio_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Savoir-faire Linux Inc. <kernel@savoirfairelinux.com>");
MODULE_DESCRIPTION("Technologic Systems TS-5500 Digital I/O driver");
Commit	Line	Data
759f5f37 VD	1	/*
	2	* Digital I/O driver for Technologic Systems TS-5500
	3	*
	4	* Copyright (c) 2012 Savoir-faire Linux Inc.
	5	* Vivien Didelot <vivien.didelot@savoirfairelinux.com>
	6	*
	7	* Technologic Systems platforms have pin blocks, exposing several Digital
	8	* Input/Output lines (DIO). This driver aims to support single pin blocks.
	9	* In that sense, the support is not limited to the TS-5500 blocks.
	10	* Actually, the following platforms have DIO support:
	11	*
	12	* TS-5500:
	13	* Documentation: http://wiki.embeddedarm.com/wiki/TS-5500
	14	* Blocks: DIO1, DIO2 and LCD port.
	15	*
	16	* TS-5600:
	17	* Documentation: http://wiki.embeddedarm.com/wiki/TS-5600
	18	* Blocks: LCD port (identical to TS-5500 LCD).
	19	*
	20	* This program is free software; you can redistribute it and/or modify
	21	* it under the terms of the GNU General Public License version 2 as
	22	* published by the Free Software Foundation.
	23	*/
	24
	25	#include <linux/bitops.h>
	26	#include <linux/gpio.h>
	27	#include <linux/io.h>
	28	#include <linux/module.h>
	29	#include <linux/platform_data/gpio-ts5500.h>
	30	#include <linux/platform_device.h>
	31	#include <linux/slab.h>
	32
	33	/* List of supported Technologic Systems platforms DIO blocks */
	34	enum ts5500_blocks { TS5500_DIO1, TS5500_DIO2, TS5500_LCD, TS5600_LCD };
	35
	36	struct ts5500_priv {
	37	const struct ts5500_dio *pinout;
	38	struct gpio_chip gpio_chip;
	39	spinlock_t lock;
	40	bool strap;
	41	u8 hwirq;
	42	};
	43
	44	/*
	45	* Hex 7D is used to control several blocks (e.g. DIO2 and LCD port).
	46	* This flag ensures that the region has been requested by this driver.
	47	*/
	48	static bool hex7d_reserved;
	49
	50	/*
	51	* This structure is used to describe capabilities of DIO lines,
	52	* such as available directions and connected interrupt (if any).
	53	*/
	54	struct ts5500_dio {
	55	const u8 value_addr;
	56	const u8 value_mask;
	57	const u8 control_addr;
	58	const u8 control_mask;
	59	const bool no_input;
	60	const bool no_output;
	61	const u8 irq;
	62	};
	63
	64	#define TS5500_DIO_IN_OUT(vaddr, vbit, caddr, cbit) \
65	{ \
66	.value_addr = vaddr, \
67	.value_mask = BIT(vbit), \
68	.control_addr = caddr, \
69	.control_mask = BIT(cbit), \
70	}
71
72	#define TS5500_DIO_IN(addr, bit) \
73	{ \
74	.value_addr = addr, \
75	.value_mask = BIT(bit), \
76	.no_output = true, \
77	}
78
79	#define TS5500_DIO_IN_IRQ(addr, bit, _irq) \
80	{ \
81	.value_addr = addr, \
82	.value_mask = BIT(bit), \
83	.no_output = true, \
84	.irq = _irq, \
85	}
86
87	#define TS5500_DIO_OUT(addr, bit) \
88	{ \
89	.value_addr = addr, \
90	.value_mask = BIT(bit), \
91	.no_input = true, \
92	}
93
94	/*
95	* Input/Output DIO lines are programmed in groups of 4. Their values are
96	* available through 4 consecutive bits in a value port, whereas the direction
97	* of these 4 lines is driven by only 1 bit in a control port.
98	*/
99	#define TS5500_DIO_GROUP(vaddr, vbitfrom, caddr, cbit) \
100	TS5500_DIO_IN_OUT(vaddr, vbitfrom + 0, caddr, cbit), \
101	TS5500_DIO_IN_OUT(vaddr, vbitfrom + 1, caddr, cbit), \
102	TS5500_DIO_IN_OUT(vaddr, vbitfrom + 2, caddr, cbit), \
103	TS5500_DIO_IN_OUT(vaddr, vbitfrom + 3, caddr, cbit)
104
105	/*
106	* TS-5500 DIO1 block
107	*
108	* value control dir hw
109	* addr bit addr bit in out irq name pin offset
110	*
111	* 0x7b 0 0x7a 0 x x DIO1_0 1 0
112	* 0x7b 1 0x7a 0 x x DIO1_1 3 1
113	* 0x7b 2 0x7a 0 x x DIO1_2 5 2
114	* 0x7b 3 0x7a 0 x x DIO1_3 7 3
115	* 0x7b 4 0x7a 1 x x DIO1_4 9 4
116	* 0x7b 5 0x7a 1 x x DIO1_5 11 5
117	* 0x7b 6 0x7a 1 x x DIO1_6 13 6
118	* 0x7b 7 0x7a 1 x x DIO1_7 15 7
119	* 0x7c 0 0x7a 5 x x DIO1_8 4 8
120	* 0x7c 1 0x7a 5 x x DIO1_9 6 9
121	* 0x7c 2 0x7a 5 x x DIO1_10 8 10
122	* 0x7c 3 0x7a 5 x x DIO1_11 10 11
123	* 0x7c 4 x DIO1_12 12 12
124	* 0x7c 5 x 7 DIO1_13 14 13
125	*/
126	static const struct ts5500_dio ts5500_dio1[] = {
127	TS5500_DIO_GROUP(0x7b, 0, 0x7a, 0),
128	TS5500_DIO_GROUP(0x7b, 4, 0x7a, 1),
129	TS5500_DIO_GROUP(0x7c, 0, 0x7a, 5),
130	TS5500_DIO_IN(0x7c, 4),
131	TS5500_DIO_IN_IRQ(0x7c, 5, 7),
132	};
133
134	/*
135	* TS-5500 DIO2 block
136	*
137	* value control dir hw
138	* addr bit addr bit in out irq name pin offset
139	*
140	* 0x7e 0 0x7d 0 x x DIO2_0 1 0
141	* 0x7e 1 0x7d 0 x x DIO2_1 3 1
142	* 0x7e 2 0x7d 0 x x DIO2_2 5 2
143	* 0x7e 3 0x7d 0 x x DIO2_3 7 3
144	* 0x7e 4 0x7d 1 x x DIO2_4 9 4
145	* 0x7e 5 0x7d 1 x x DIO2_5 11 5
146	* 0x7e 6 0x7d 1 x x DIO2_6 13 6
147	* 0x7e 7 0x7d 1 x x DIO2_7 15 7
148	* 0x7f 0 0x7d 5 x x DIO2_8 4 8
149	* 0x7f 1 0x7d 5 x x DIO2_9 6 9
150	* 0x7f 2 0x7d 5 x x DIO2_10 8 10
151	* 0x7f 3 0x7d 5 x x DIO2_11 10 11
152	* 0x7f 4 x 6 DIO2_13 14 12
153	*/
154	static const struct ts5500_dio ts5500_dio2[] = {
155	TS5500_DIO_GROUP(0x7e, 0, 0x7d, 0),
156	TS5500_DIO_GROUP(0x7e, 4, 0x7d, 1),
157	TS5500_DIO_GROUP(0x7f, 0, 0x7d, 5),
158	TS5500_DIO_IN_IRQ(0x7f, 4, 6),
159	};
160
161	/*
162	* TS-5500 LCD port used as DIO block
163	* TS-5600 LCD port is identical
164	*
165	* value control dir hw
166	* addr bit addr bit in out irq name pin offset
167	*
168	* 0x72 0 0x7d 2 x x LCD_0 8 0
169	* 0x72 1 0x7d 2 x x LCD_1 7 1
170	* 0x72 2 0x7d 2 x x LCD_2 10 2
171	* 0x72 3 0x7d 2 x x LCD_3 9 3
172	* 0x72 4 0x7d 3 x x LCD_4 12 4
173	* 0x72 5 0x7d 3 x x LCD_5 11 5
174	* 0x72 6 0x7d 3 x x LCD_6 14 6
175	* 0x72 7 0x7d 3 x x LCD_7 13 7
176	* 0x73 0 x LCD_EN 5 8
177	* 0x73 6 x LCD_WR 6 9
178	* 0x73 7 x 1 LCD_RS 3 10
179	*/
180	static const struct ts5500_dio ts5500_lcd[] = {
181	TS5500_DIO_GROUP(0x72, 0, 0x7d, 2),
182	TS5500_DIO_GROUP(0x72, 4, 0x7d, 3),
183	TS5500_DIO_OUT(0x73, 0),
184	TS5500_DIO_IN(0x73, 6),
185	TS5500_DIO_IN_IRQ(0x73, 7, 1),
186	};
187
188	static inline struct ts5500_priv ts5500_gc_to_priv(struct gpio_chip chip)
189	{
190	return container_of(chip, struct ts5500_priv, gpio_chip);
191	}
192
193	static inline void ts5500_set_mask(u8 mask, u8 addr)
194	{
195	u8 val = inb(addr);
196	val \|= mask;
197	outb(val, addr);
198	}
199
200	static inline void ts5500_clear_mask(u8 mask, u8 addr)
201	{
202	u8 val = inb(addr);
203	val &= ~mask;
204	outb(val, addr);
205	}
206
207	static int ts5500_gpio_input(struct gpio_chip *chip, unsigned offset)
208	{
209	struct ts5500_priv *priv = ts5500_gc_to_priv(chip);
210	const struct ts5500_dio line = priv->pinout[offset];
211	unsigned long flags;
212
213	if (line.no_input)
214	return -ENXIO;
215
216	if (line.no_output)
217	return 0;
218
219	spin_lock_irqsave(&priv->lock, flags);
220	ts5500_clear_mask(line.control_mask, line.control_addr);
221	spin_unlock_irqrestore(&priv->lock, flags);
222
223	return 0;
224	}
225
226	static int ts5500_gpio_get(struct gpio_chip *chip, unsigned offset)
227	{
228	struct ts5500_priv *priv = ts5500_gc_to_priv(chip);
229	const struct ts5500_dio line = priv->pinout[offset];
230
231	return !!(inb(line.value_addr) & line.value_mask);
232	}
233
234	static int ts5500_gpio_output(struct gpio_chip *chip, unsigned offset, int val)
235	{
236	struct ts5500_priv *priv = ts5500_gc_to_priv(chip);
237	const struct ts5500_dio line = priv->pinout[offset];
238	unsigned long flags;
239
240	if (line.no_output)
241	return -ENXIO;
242
243	spin_lock_irqsave(&priv->lock, flags);
244	if (!line.no_input)
245	ts5500_set_mask(line.control_mask, line.control_addr);
246
247	if (val)
248	ts5500_set_mask(line.value_mask, line.value_addr);
249	else
250	ts5500_clear_mask(line.value_mask, line.value_addr);
251	spin_unlock_irqrestore(&priv->lock, flags);
252
253	return 0;
254	}
255
256	static void ts5500_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
257	{
258	struct ts5500_priv *priv = ts5500_gc_to_priv(chip);
259	const struct ts5500_dio line = priv->pinout[offset];
260	unsigned long flags;
261
262	spin_lock_irqsave(&priv->lock, flags);
263	if (val)
264	ts5500_set_mask(line.value_mask, line.value_addr);
265	else
266	ts5500_clear_mask(line.value_mask, line.value_addr);
267	spin_unlock_irqrestore(&priv->lock, flags);
268	}
269
270	static int ts5500_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
271	{
272	struct ts5500_priv *priv = ts5500_gc_to_priv(chip);
273	const struct ts5500_dio *block = priv->pinout;
274	const struct ts5500_dio line = block[offset];
275
276	/* Only one pin is connected to an interrupt */
277	if (line.irq)
278	return line.irq;
279
280	/* As this pin is input-only, we may strap it to another in/out pin */
281	if (priv->strap)
282	return priv->hwirq;
283
284	return -ENXIO;
285	}
286
287	static int ts5500_enable_irq(struct ts5500_priv *priv)
288	{
289	int ret = 0;
290	unsigned long flags;
291
292	spin_lock_irqsave(&priv->lock, flags);
293	if (priv->hwirq == 7)
294	ts5500_set_mask(BIT(7), 0x7a); /* DIO1_13 on IRQ7 */
295	else if (priv->hwirq == 6)
296	ts5500_set_mask(BIT(7), 0x7d); /* DIO2_13 on IRQ6 */
297	else if (priv->hwirq == 1)
298	ts5500_set_mask(BIT(6), 0x7d); /* LCD_RS on IRQ1 */
299	else
300	ret = -EINVAL;
301	spin_unlock_irqrestore(&priv->lock, flags);
302
303	return ret;
304	}
305
306	static void ts5500_disable_irq(struct ts5500_priv *priv)
307	{
308	unsigned long flags;
309
310	spin_lock_irqsave(&priv->lock, flags);
311	if (priv->hwirq == 7)
312	ts5500_clear_mask(BIT(7), 0x7a); /* DIO1_13 on IRQ7 */
313	else if (priv->hwirq == 6)
314	ts5500_clear_mask(BIT(7), 0x7d); /* DIO2_13 on IRQ6 */
315	else if (priv->hwirq == 1)
316	ts5500_clear_mask(BIT(6), 0x7d); /* LCD_RS on IRQ1 */
317	else
318	dev_err(priv->gpio_chip.dev, "invalid hwirq %d\n", priv->hwirq);
319	spin_unlock_irqrestore(&priv->lock, flags);
320	}
321
0fe763c5	322	static int ts5500_dio_probe(struct platform_device *pdev)
759f5f37 VD	323	{
	324	enum ts5500_blocks block = platform_get_device_id(pdev)->driver_data;
	325	struct ts5500_dio_platform_data *pdata = pdev->dev.platform_data;
	326	struct device *dev = &pdev->dev;
	327	const char *name = dev_name(dev);
	328	struct ts5500_priv *priv;
	329	struct resource *res;
	330	unsigned long flags;
	331	int ret;
	332
	333	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	334	if (!res) {
	335	dev_err(dev, "missing IRQ resource\n");
	336	return -EINVAL;
	337	}
	338
	339	priv = devm_kzalloc(dev, sizeof(struct ts5500_priv), GFP_KERNEL);
	340	if (!priv)
	341	return -ENOMEM;
	342
	343	platform_set_drvdata(pdev, priv);
	344	priv->hwirq = res->start;
	345	spin_lock_init(&priv->lock);
	346
	347	priv->gpio_chip.owner = THIS_MODULE;
	348	priv->gpio_chip.label = name;
	349	priv->gpio_chip.dev = dev;
	350	priv->gpio_chip.direction_input = ts5500_gpio_input;
	351	priv->gpio_chip.direction_output = ts5500_gpio_output;
	352	priv->gpio_chip.get = ts5500_gpio_get;
	353	priv->gpio_chip.set = ts5500_gpio_set;
	354	priv->gpio_chip.to_irq = ts5500_gpio_to_irq;
	355	priv->gpio_chip.base = -1;
	356	if (pdata) {
	357	priv->gpio_chip.base = pdata->base;
	358	priv->strap = pdata->strap;
	359	}
	360
	361	switch (block) {
	362	case TS5500_DIO1:
	363	priv->pinout = ts5500_dio1;
	364	priv->gpio_chip.ngpio = ARRAY_SIZE(ts5500_dio1);
	365
	366	if (!devm_request_region(dev, 0x7a, 3, name)) {
	367	dev_err(dev, "failed to request %s ports\n", name);
	368	return -EBUSY;
	369	}
	370	break;
	371	case TS5500_DIO2:
	372	priv->pinout = ts5500_dio2;
	373	priv->gpio_chip.ngpio = ARRAY_SIZE(ts5500_dio2);
	374
	375	if (!devm_request_region(dev, 0x7e, 2, name)) {
	376	dev_err(dev, "failed to request %s ports\n", name);
	377	return -EBUSY;
	378	}
	379
	380	if (hex7d_reserved)
	381	break;
	382
	383	if (!devm_request_region(dev, 0x7d, 1, name)) {
	384	dev_err(dev, "failed to request %s 7D\n", name);
	385	return -EBUSY;
	386	}
387
388	hex7d_reserved = true;
389	break;
390	case TS5500_LCD:
391	case TS5600_LCD:
392	priv->pinout = ts5500_lcd;
393	priv->gpio_chip.ngpio = ARRAY_SIZE(ts5500_lcd);
394
395	if (!devm_request_region(dev, 0x72, 2, name)) {
396	dev_err(dev, "failed to request %s ports\n", name);
397	return -EBUSY;
398	}
399
400	if (!hex7d_reserved) {
401	if (!devm_request_region(dev, 0x7d, 1, name)) {
402	dev_err(dev, "failed to request %s 7D\n", name);
403	return -EBUSY;
404	}
405
406	hex7d_reserved = true;
407	}
408
409	/* Ensure usage of LCD port as DIO */
410	spin_lock_irqsave(&priv->lock, flags);
411	ts5500_clear_mask(BIT(4), 0x7d);
412	spin_unlock_irqrestore(&priv->lock, flags);
413	break;
414	}
415
416	ret = gpiochip_add(&priv->gpio_chip);
417	if (ret) {
418	dev_err(dev, "failed to register the gpio chip\n");
419	return ret;
420	}
421
422	ret = ts5500_enable_irq(priv);
423	if (ret) {
424	dev_err(dev, "invalid interrupt %d\n", priv->hwirq);
425	goto cleanup;
426	}
427
428	return 0;
429	cleanup:
430	if (gpiochip_remove(&priv->gpio_chip))
431	dev_err(dev, "failed to remove gpio chip\n");
432	return ret;
433	}
434
0fe763c5	435	static int ts5500_dio_remove(struct platform_device *pdev)
759f5f37 VD	436	{
	437	struct ts5500_priv *priv = platform_get_drvdata(pdev);
	438
	439	ts5500_disable_irq(priv);
	440	return gpiochip_remove(&priv->gpio_chip);
	441	}
	442
	443	static struct platform_device_id ts5500_dio_ids[] = {
	444	{ "ts5500-dio1", TS5500_DIO1 },
	445	{ "ts5500-dio2", TS5500_DIO2 },
	446	{ "ts5500-dio-lcd", TS5500_LCD },
	447	{ "ts5600-dio-lcd", TS5600_LCD },
	448	{ }
	449	};
	450	MODULE_DEVICE_TABLE(platform, ts5500_dio_ids);
	451
	452	static struct platform_driver ts5500_dio_driver = {
	453	.driver = {
	454	.name = "ts5500-dio",
	455	.owner = THIS_MODULE,
	456	},
	457	.probe = ts5500_dio_probe,
0fe763c5	458	.remove = ts5500_dio_remove,
759f5f37 VD	459	.id_table = ts5500_dio_ids,
	460	};
	461
	462	module_platform_driver(ts5500_dio_driver);
	463
	464	MODULE_LICENSE("GPL");
	465	MODULE_AUTHOR("Savoir-faire Linux Inc. <kernel@savoirfairelinux.com>");
	466	MODULE_DESCRIPTION("Technologic Systems TS-5500 Digital I/O driver");