[linux-2.6-block.git] / drivers / auxdisplay / hd44780.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * HD44780 Character LCD driver for Linux
 *
 * Copyright (C) 2000-2008, Willy Tarreau <w@1wt.eu>
 * Copyright (C) 2016-2017 Glider bvba
 */

#include <linux/delay.h>
#include <linux/gpio/consumer.h>
#include <linux/module.h>
#include <linux/mod_devicetable.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)
{
	DECLARE_BITMAP(values, 10); /* for DATA[0-7], RS, RW */
	unsigned int n;

	values[0] = val;
	__assign_bit(8, values, rs);
	n = hd->pins[PIN_CTRL_RW] ? 10 : 9;

	/* Present the data to the port */
	gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA0], NULL, 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)
{
	DECLARE_BITMAP(values, 6); /* for DATA[4-7], RS, RW */
	unsigned int n;

	/* High nibble + RS, RW */
	values[0] = val >> 4;
	__assign_bit(4, values, rs);
	n = hd->pins[PIN_CTRL_RW] ? 6 : 5;

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

	hd44780_strobe_gpio(hd);

	/* Low nibble */
	values[0] &= ~0x0fUL;
	values[0] |= val & 0x0f;

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

	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)
{
	DECLARE_BITMAP(values, 6); /* for DATA[4-7], RS, RW */
	struct hd44780 *hd = lcd->drvdata;
	unsigned int n;

	/* Command nibble + RS, RW */
	values[0] = cmd & 0x0f;
	n = hd->pins[PIN_CTRL_RW] ? 6 : 5;

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

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