[mirror_ubuntu-artful-kernel.git] / drivers / auxdisplay / hd44780.c

/*
 * HD44780 Character LCD driver for Linux
 *
 * Copyright (C) 2000-2008, Willy Tarreau <w@1wt.eu>
 * Copyright (C) 2016-2017 Glider bvba
 *
 * 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; either version
 * 2 of the License, or (at your option) any later version.
 */

#include <linux/delay.h>
#include <linux/gpio/consumer.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/property.h>
#include <linux/slab.h>

#include <misc/charlcd.h>


enum hd44780_pin {
	/* Order does matter due to writing to GPIO array subsets! */
	PIN_DATA0,	/* Optional */
	PIN_DATA1,	/* Optional */
	PIN_DATA2,	/* Optional */
	PIN_DATA3,	/* Optional */
	PIN_DATA4,
	PIN_DATA5,
	PIN_DATA6,
	PIN_DATA7,
	PIN_CTRL_RS,
	PIN_CTRL_RW,	/* Optional */
	PIN_CTRL_E,
	PIN_CTRL_BL,   /* Optional */
	PIN_NUM
};

struct hd44780 {
	struct gpio_desc *pins[PIN_NUM];
};

static void hd44780_backlight(struct charlcd *lcd, int on)
{
	struct hd44780 *hd = lcd->drvdata;

	if (hd->pins[PIN_CTRL_BL])
		gpiod_set_value_cansleep(hd->pins[PIN_CTRL_BL], on);
}

static void hd44780_strobe_gpio(struct hd44780 *hd)
{
	/* Maintain the data during 20 us before the strobe */
	udelay(20);

	gpiod_set_value_cansleep(hd->pins[PIN_CTRL_E], 1);

	/* Maintain the strobe during 40 us */
	udelay(40);

	gpiod_set_value_cansleep(hd->pins[PIN_CTRL_E], 0);
}

/* write to an LCD panel register in 8 bit GPIO mode */
static void hd44780_write_gpio8(struct hd44780 *hd, u8 val, unsigned int rs)
{
	int values[10];	/* for DATA[0-7], RS, RW */
	unsigned int i, n;

	for (i = 0; i < 8; i++)
		values[PIN_DATA0 + i] = !!(val & BIT(i));
	values[PIN_CTRL_RS] = rs;
	n = 9;
	if (hd->pins[PIN_CTRL_RW]) {
		values[PIN_CTRL_RW] = 0;
		n++;
	}

	/* Present the data to the port */
	gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA0], values);

	hd44780_strobe_gpio(hd);
}

/* write to an LCD panel register in 4 bit GPIO mode */
static void hd44780_write_gpio4(struct hd44780 *hd, u8 val, unsigned int rs)
{
	int values[10];	/* for DATA[0-7], RS, RW, but DATA[0-3] is unused */
	unsigned int i, n;

	/* High nibble + RS, RW */
	for (i = 4; i < 8; i++)
		values[PIN_DATA0 + i] = !!(val & BIT(i));
	values[PIN_CTRL_RS] = rs;
	n = 5;
	if (hd->pins[PIN_CTRL_RW]) {
		values[PIN_CTRL_RW] = 0;
		n++;
	}

	/* Present the data to the port */
	gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4],
				       &values[PIN_DATA4]);

	hd44780_strobe_gpio(hd);

	/* Low nibble */
	for (i = 0; i < 4; i++)
		values[PIN_DATA4 + i] = !!(val & BIT(i));

	/* Present the data to the port */
	gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4],
				       &values[PIN_DATA4]);

	hd44780_strobe_gpio(hd);
}

/* Send a command to the LCD panel in 8 bit GPIO mode */
static void hd44780_write_cmd_gpio8(struct charlcd *lcd, int cmd)
{
	struct hd44780 *hd = lcd->drvdata;

	hd44780_write_gpio8(hd, cmd, 0);

	/* The shortest command takes at least 120 us */
	udelay(120);
}

/* Send data to the LCD panel in 8 bit GPIO mode */
static void hd44780_write_data_gpio8(struct charlcd *lcd, int data)
{
	struct hd44780 *hd = lcd->drvdata;

	hd44780_write_gpio8(hd, data, 1);

	/* The shortest data takes at least 45 us */
	udelay(45);
}

static const struct charlcd_ops hd44780_ops_gpio8 = {
	.write_cmd	= hd44780_write_cmd_gpio8,
	.write_data	= hd44780_write_data_gpio8,
	.backlight	= hd44780_backlight,
};

/* Send a command to the LCD panel in 4 bit GPIO mode */
static void hd44780_write_cmd_gpio4(struct charlcd *lcd, int cmd)
{
	struct hd44780 *hd = lcd->drvdata;

	hd44780_write_gpio4(hd, cmd, 0);

	/* The shortest command takes at least 120 us */
	udelay(120);
}

/* Send 4-bits of a command to the LCD panel in raw 4 bit GPIO mode */
static void hd44780_write_cmd_raw_gpio4(struct charlcd *lcd, int cmd)
{
	int values[10];	/* for DATA[0-7], RS, RW, but DATA[0-3] is unused */
	struct hd44780 *hd = lcd->drvdata;
	unsigned int i, n;

	/* Command nibble + RS, RW */
	for (i = 0; i < 4; i++)
		values[PIN_DATA4 + i] = !!(cmd & BIT(i));
	values[PIN_CTRL_RS] = 0;
	n = 5;
	if (hd->pins[PIN_CTRL_RW]) {
		values[PIN_CTRL_RW] = 0;
		n++;
	}

	/* Present the data to the port */
	gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4],
				       &values[PIN_DATA4]);

	hd44780_strobe_gpio(hd);
}

/* Send data to the LCD panel in 4 bit GPIO mode */
static void hd44780_write_data_gpio4(struct charlcd *lcd, int data)
{
	struct hd44780 *hd = lcd->drvdata;

	hd44780_write_gpio4(hd, data, 1);

	/* The shortest data takes at least 45 us */
	udelay(45);
}

static const struct charlcd_ops hd44780_ops_gpio4 = {
	.write_cmd	= hd44780_write_cmd_gpio4,
	.write_cmd_raw4	= hd44780_write_cmd_raw_gpio4,
	.write_data	= hd44780_write_data_gpio4,
	.backlight	= hd44780_backlight,
};

static int hd44780_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	unsigned int i, base;
	struct charlcd *lcd;
	struct hd44780 *hd;
	int ifwidth, ret;

	/* Required pins */
	ifwidth = gpiod_count(dev, "data");
	if (ifwidth < 0)
		return ifwidth;

	switch (ifwidth) {
	case 4:
		base = PIN_DATA4;
		break;
	case 8:
		base = PIN_DATA0;
		break;
	default:
		return -EINVAL;
	}

	lcd = charlcd_alloc(sizeof(struct hd44780));
	if (!lcd)
		return -ENOMEM;

	hd = lcd->drvdata;

	for (i = 0; i < ifwidth; i++) {
		hd->pins[base + i] = devm_gpiod_get_index(dev, "data", i,
							  GPIOD_OUT_LOW);
		if (IS_ERR(hd->pins[base + i])) {
			ret = PTR_ERR(hd->pins[base + i]);
			goto fail;
		}
	}

	hd->pins[PIN_CTRL_E] = devm_gpiod_get(dev, "enable", GPIOD_OUT_LOW);
	if (IS_ERR(hd->pins[PIN_CTRL_E])) {
		ret = PTR_ERR(hd->pins[PIN_CTRL_E]);
		goto fail;
	}

	hd->pins[PIN_CTRL_RS] = devm_gpiod_get(dev, "rs", GPIOD_OUT_HIGH);
	if (IS_ERR(hd->pins[PIN_CTRL_RS])) {
		ret = PTR_ERR(hd->pins[PIN_CTRL_RS]);
		goto fail;
	}

	/* Optional pins */
	hd->pins[PIN_CTRL_RW] = devm_gpiod_get_optional(dev, "rw",
							GPIOD_OUT_LOW);
	if (IS_ERR(hd->pins[PIN_CTRL_RW])) {
		ret = PTR_ERR(hd->pins[PIN_CTRL_RW]);
		goto fail;
	}

	hd->pins[PIN_CTRL_BL] = devm_gpiod_get_optional(dev, "backlight",
							GPIOD_OUT_LOW);
	if (IS_ERR(hd->pins[PIN_CTRL_BL])) {
		ret = PTR_ERR(hd->pins[PIN_CTRL_BL]);
		goto fail;
	}

	/* Required properties */
	ret = device_property_read_u32(dev, "display-height-chars",
				       &lcd->height);
	if (ret)
		goto fail;
	ret = device_property_read_u32(dev, "display-width-chars", &lcd->width);
	if (ret)
		goto fail;

	/*
	 * On displays with more than two rows, the internal buffer width is
	 * usually equal to the display width
	 */
	if (lcd->height > 2)
		lcd->bwidth = lcd->width;

	/* Optional properties */
	device_property_read_u32(dev, "internal-buffer-width", &lcd->bwidth);

	lcd->ifwidth = ifwidth;
	lcd->ops = ifwidth == 8 ? &hd44780_ops_gpio8 : &hd44780_ops_gpio4;

	ret = charlcd_register(lcd);
	if (ret)
		goto fail;

	platform_set_drvdata(pdev, lcd);
	return 0;

fail:
	kfree(lcd);
	return ret;
}

static int hd44780_remove(struct platform_device *pdev)
{
	struct charlcd *lcd = platform_get_drvdata(pdev);

	charlcd_unregister(lcd);
	return 0;
}

static const struct of_device_id hd44780_of_match[] = {
	{ .compatible = "hit,hd44780" },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, hd44780_of_match);

static struct platform_driver hd44780_driver = {
	.probe = hd44780_probe,
	.remove = hd44780_remove,
	.driver		= {
		.name	= "hd44780",
		.of_match_table = hd44780_of_match,
	},
};

module_platform_driver(hd44780_driver);
MODULE_DESCRIPTION("HD44780 Character LCD driver");
MODULE_AUTHOR("Geert Uytterhoeven <geert@linux-m68k.org>");
MODULE_LICENSE("GPL");
Commit	Line	Data
d47d8836 GU	1	/*
	2	* HD44780 Character LCD driver for Linux
	3	*
	4	* Copyright (C) 2000-2008, Willy Tarreau <w@1wt.eu>
	5	* Copyright (C) 2016-2017 Glider bvba
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License
	9	* as published by the Free Software Foundation; either version
	10	* 2 of the License, or (at your option) any later version.
	11	*/
	12
	13	#include <linux/delay.h>
	14	#include <linux/gpio/consumer.h>
	15	#include <linux/module.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/property.h>
	18	#include <linux/slab.h>
	19
	20	#include <misc/charlcd.h>
	21
	22
	23	enum hd44780_pin {
	24	/* Order does matter due to writing to GPIO array subsets! */
	25	PIN_DATA0, /* Optional */
	26	PIN_DATA1, /* Optional */
	27	PIN_DATA2, /* Optional */
	28	PIN_DATA3, /* Optional */
	29	PIN_DATA4,
	30	PIN_DATA5,
	31	PIN_DATA6,
	32	PIN_DATA7,
	33	PIN_CTRL_RS,
	34	PIN_CTRL_RW, /* Optional */
	35	PIN_CTRL_E,
	36	PIN_CTRL_BL, /* Optional */
	37	PIN_NUM
	38	};
	39
	40	struct hd44780 {
	41	struct gpio_desc *pins[PIN_NUM];
	42	};
	43
	44	static void hd44780_backlight(struct charlcd *lcd, int on)
	45	{
	46	struct hd44780 *hd = lcd->drvdata;
	47
	48	if (hd->pins[PIN_CTRL_BL])
	49	gpiod_set_value_cansleep(hd->pins[PIN_CTRL_BL], on);
	50	}
	51
	52	static void hd44780_strobe_gpio(struct hd44780 *hd)
	53	{
	54	/* Maintain the data during 20 us before the strobe */
	55	udelay(20);
	56
	57	gpiod_set_value_cansleep(hd->pins[PIN_CTRL_E], 1);
	58
	59	/* Maintain the strobe during 40 us */
	60	udelay(40);
	61
	62	gpiod_set_value_cansleep(hd->pins[PIN_CTRL_E], 0);
	63	}
	64
65	/* write to an LCD panel register in 8 bit GPIO mode */
66	static void hd44780_write_gpio8(struct hd44780 *hd, u8 val, unsigned int rs)
67	{
68	int values[10]; /* for DATA[0-7], RS, RW */
69	unsigned int i, n;
70
71	for (i = 0; i < 8; i++)
72	values[PIN_DATA0 + i] = !!(val & BIT(i));
73	values[PIN_CTRL_RS] = rs;
74	n = 9;
75	if (hd->pins[PIN_CTRL_RW]) {
76	values[PIN_CTRL_RW] = 0;
77	n++;
78	}
79
80	/* Present the data to the port */
81	gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA0], values);
82
83	hd44780_strobe_gpio(hd);
84	}
85
86	/* write to an LCD panel register in 4 bit GPIO mode */
87	static void hd44780_write_gpio4(struct hd44780 *hd, u8 val, unsigned int rs)
88	{
89	int values[10]; /* for DATA[0-7], RS, RW, but DATA[0-3] is unused */
90	unsigned int i, n;
91
92	/* High nibble + RS, RW */
93	for (i = 4; i < 8; i++)
94	values[PIN_DATA0 + i] = !!(val & BIT(i));
95	values[PIN_CTRL_RS] = rs;
96	n = 5;
97	if (hd->pins[PIN_CTRL_RW]) {
98	values[PIN_CTRL_RW] = 0;
99	n++;
100	}
101
102	/* Present the data to the port */
103	gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4],
104	&values[PIN_DATA4]);
105
106	hd44780_strobe_gpio(hd);
107
108	/* Low nibble */
109	for (i = 0; i < 4; i++)
110	values[PIN_DATA4 + i] = !!(val & BIT(i));
111
112	/* Present the data to the port */
113	gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4],
114	&values[PIN_DATA4]);
115
116	hd44780_strobe_gpio(hd);
117	}
118
119	/* Send a command to the LCD panel in 8 bit GPIO mode */
120	static void hd44780_write_cmd_gpio8(struct charlcd *lcd, int cmd)
121	{
122	struct hd44780 *hd = lcd->drvdata;
123
124	hd44780_write_gpio8(hd, cmd, 0);
125
126	/* The shortest command takes at least 120 us */
127	udelay(120);
128	}
129
130	/* Send data to the LCD panel in 8 bit GPIO mode */
131	static void hd44780_write_data_gpio8(struct charlcd *lcd, int data)
132	{
133	struct hd44780 *hd = lcd->drvdata;
134
135	hd44780_write_gpio8(hd, data, 1);
136
137	/* The shortest data takes at least 45 us */
138	udelay(45);
139	}
140
141	static const struct charlcd_ops hd44780_ops_gpio8 = {
142	.write_cmd = hd44780_write_cmd_gpio8,
143	.write_data = hd44780_write_data_gpio8,
144	.backlight = hd44780_backlight,
145	};
146
147	/* Send a command to the LCD panel in 4 bit GPIO mode */
148	static void hd44780_write_cmd_gpio4(struct charlcd *lcd, int cmd)
149	{
150	struct hd44780 *hd = lcd->drvdata;
151
152	hd44780_write_gpio4(hd, cmd, 0);
153
154	/* The shortest command takes at least 120 us */
155	udelay(120);
156	}
157
158	/* Send 4-bits of a command to the LCD panel in raw 4 bit GPIO mode */
159	static void hd44780_write_cmd_raw_gpio4(struct charlcd *lcd, int cmd)
160	{
161	int values[10]; /* for DATA[0-7], RS, RW, but DATA[0-3] is unused */
162	struct hd44780 *hd = lcd->drvdata;
163	unsigned int i, n;
164
165	/* Command nibble + RS, RW */
166	for (i = 0; i < 4; i++)
167	values[PIN_DATA4 + i] = !!(cmd & BIT(i));
168	values[PIN_CTRL_RS] = 0;
169	n = 5;
170	if (hd->pins[PIN_CTRL_RW]) {
171	values[PIN_CTRL_RW] = 0;
172	n++;
173	}
174
175	/* Present the data to the port */
176	gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4],
177	&values[PIN_DATA4]);
178
179	hd44780_strobe_gpio(hd);
180	}
181
182	/* Send data to the LCD panel in 4 bit GPIO mode */
183	static void hd44780_write_data_gpio4(struct charlcd *lcd, int data)
184	{
185	struct hd44780 *hd = lcd->drvdata;
186
187	hd44780_write_gpio4(hd, data, 1);
188
189	/* The shortest data takes at least 45 us */
190	udelay(45);
191	}
192
193	static const struct charlcd_ops hd44780_ops_gpio4 = {
194	.write_cmd = hd44780_write_cmd_gpio4,
195	.write_cmd_raw4 = hd44780_write_cmd_raw_gpio4,
196	.write_data = hd44780_write_data_gpio4,
197	.backlight = hd44780_backlight,
198	};
199
200	static int hd44780_probe(struct platform_device *pdev)
201	{
202	struct device *dev = &pdev->dev;
203	unsigned int i, base;
204	struct charlcd *lcd;
205	struct hd44780 *hd;
206	int ifwidth, ret;
207
208	/* Required pins */
209	ifwidth = gpiod_count(dev, "data");
210	if (ifwidth < 0)
211	return ifwidth;
212
213	switch (ifwidth) {
214	case 4:
215	base = PIN_DATA4;
216	break;
217	case 8:
218	base = PIN_DATA0;
219	break;
220	default:
221	return -EINVAL;
222	}
223
224	lcd = charlcd_alloc(sizeof(struct hd44780));
225	if (!lcd)
226	return -ENOMEM;
227
228	hd = lcd->drvdata;
229
230	for (i = 0; i < ifwidth; i++) {
231	hd->pins[base + i] = devm_gpiod_get_index(dev, "data", i,
232	GPIOD_OUT_LOW);
233	if (IS_ERR(hd->pins[base + i])) {
234	ret = PTR_ERR(hd->pins[base + i]);
235	goto fail;
236	}
237	}
238
239	hd->pins[PIN_CTRL_E] = devm_gpiod_get(dev, "enable", GPIOD_OUT_LOW);
240	if (IS_ERR(hd->pins[PIN_CTRL_E])) {
241	ret = PTR_ERR(hd->pins[PIN_CTRL_E]);
242	goto fail;
243	}
244
245	hd->pins[PIN_CTRL_RS] = devm_gpiod_get(dev, "rs", GPIOD_OUT_HIGH);
246	if (IS_ERR(hd->pins[PIN_CTRL_RS])) {
247	ret = PTR_ERR(hd->pins[PIN_CTRL_RS]);
248	goto fail;
249	}
250
251	/* Optional pins */
252	hd->pins[PIN_CTRL_RW] = devm_gpiod_get_optional(dev, "rw",
253	GPIOD_OUT_LOW);
254	if (IS_ERR(hd->pins[PIN_CTRL_RW])) {
255	ret = PTR_ERR(hd->pins[PIN_CTRL_RW]);
256	goto fail;
257	}
258
259	hd->pins[PIN_CTRL_BL] = devm_gpiod_get_optional(dev, "backlight",
260	GPIOD_OUT_LOW);
261	if (IS_ERR(hd->pins[PIN_CTRL_BL])) {
262	ret = PTR_ERR(hd->pins[PIN_CTRL_BL]);
263	goto fail;
264	}
265
266	/* Required properties */
c7c3f096 GU	267	ret = device_property_read_u32(dev, "display-height-chars",
c7c3f096 GU	268	&lcd->height);
d47d8836 GU	269	if (ret)
d47d8836 GU	270	goto fail;
c7c3f096	271	ret = device_property_read_u32(dev, "display-width-chars", &lcd->width);
d47d8836 GU	272	if (ret)
	273	goto fail;
	274
	275	/*
	276	* On displays with more than two rows, the internal buffer width is
	277	* usually equal to the display width
	278	*/
	279	if (lcd->height > 2)
	280	lcd->bwidth = lcd->width;
	281
	282	/* Optional properties */
	283	device_property_read_u32(dev, "internal-buffer-width", &lcd->bwidth);
	284
	285	lcd->ifwidth = ifwidth;
	286	lcd->ops = ifwidth == 8 ? &hd44780_ops_gpio8 : &hd44780_ops_gpio4;
	287
	288	ret = charlcd_register(lcd);
	289	if (ret)
	290	goto fail;
	291
	292	platform_set_drvdata(pdev, lcd);
	293	return 0;
	294
	295	fail:
	296	kfree(lcd);
	297	return ret;
	298	}
	299
	300	static int hd44780_remove(struct platform_device *pdev)
	301	{
	302	struct charlcd *lcd = platform_get_drvdata(pdev);
	303
	304	charlcd_unregister(lcd);
	305	return 0;
	306	}
	307
	308	static const struct of_device_id hd44780_of_match[] = {
	309	{ .compatible = "hit,hd44780" },
	310	{ /* sentinel */ }
	311	};
	312	MODULE_DEVICE_TABLE(of, hd44780_of_match);
	313
	314	static struct platform_driver hd44780_driver = {
	315	.probe = hd44780_probe,
	316	.remove = hd44780_remove,
	317	.driver = {
	318	.name = "hd44780",
	319	.of_match_table = hd44780_of_match,
	320	},
	321	};
	322
	323	module_platform_driver(hd44780_driver);
	324	MODULE_DESCRIPTION("HD44780 Character LCD driver");
	325	MODULE_AUTHOR("Geert Uytterhoeven <geert@linux-m68k.org>");
	326	MODULE_LICENSE("GPL");