[linux-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 "charlcd.h"
#include "hd44780_common.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, enum charlcd_onoff on)
{
	struct hd44780_common *hdc = lcd->drvdata;
	struct hd44780 *hd = hdc->hd44780;

	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 hd44780_common *hdc, int cmd)
{
	struct hd44780 *hd = hdc->hd44780;

	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 hd44780_common *hdc, int data)
{
	struct hd44780 *hd = hdc->hd44780;

	hd44780_write_gpio8(hd, data, 1);

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

static const struct charlcd_ops hd44780_ops_gpio8 = {
	.backlight	= hd44780_backlight,
	.print		= hd44780_common_print,
	.gotoxy		= hd44780_common_gotoxy,
	.home		= hd44780_common_home,
	.clear_display	= hd44780_common_clear_display,
	.init_display	= hd44780_common_init_display,
	.shift_cursor	= hd44780_common_shift_cursor,
	.shift_display	= hd44780_common_shift_display,
	.display	= hd44780_common_display,
	.cursor		= hd44780_common_cursor,
	.blink		= hd44780_common_blink,
	.fontsize	= hd44780_common_fontsize,
	.lines		= hd44780_common_lines,
	.redefine_char	= hd44780_common_redefine_char,
};

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

	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 hd44780_common *hdc, int cmd)
{
	DECLARE_BITMAP(values, 6); /* for DATA[4-7], RS, RW */
	struct hd44780 *hd = hdc->hd44780;
	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 hd44780_common *hdc, int data)
{
	struct hd44780 *hd = hdc->hd44780;

	hd44780_write_gpio4(hd, data, 1);

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

static const struct charlcd_ops hd44780_ops_gpio4 = {
	.backlight	= hd44780_backlight,
	.print		= hd44780_common_print,
	.gotoxy		= hd44780_common_gotoxy,
	.home		= hd44780_common_home,
	.clear_display	= hd44780_common_clear_display,
	.init_display	= hd44780_common_init_display,
	.shift_cursor	= hd44780_common_shift_cursor,
	.shift_display	= hd44780_common_shift_display,
	.display	= hd44780_common_display,
	.cursor		= hd44780_common_cursor,
	.blink		= hd44780_common_blink,
	.fontsize	= hd44780_common_fontsize,
	.lines		= hd44780_common_lines,
	.redefine_char	= hd44780_common_redefine_char,
};

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

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

	hdc = hd44780_common_alloc();
	if (!hdc)
		return -ENOMEM;

	lcd = charlcd_alloc();
	if (!lcd)
		goto fail1;

	hd = kzalloc(sizeof(struct hd44780), GFP_KERNEL);
	if (!hd)
		goto fail2;

	hdc->hd44780 = hd;
	lcd->drvdata = hdc;
	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 fail3;
		}
	}

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

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

	/* 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 fail3;
	}

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

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

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

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

	hdc->ifwidth = ifwidth;
	if (ifwidth == 8) {
		lcd->ops = &hd44780_ops_gpio8;
		hdc->write_data = hd44780_write_data_gpio8;
		hdc->write_cmd = hd44780_write_cmd_gpio8;
	} else {
		lcd->ops = &hd44780_ops_gpio4;
		hdc->write_data = hd44780_write_data_gpio4;
		hdc->write_cmd = hd44780_write_cmd_gpio4;
		hdc->write_cmd_raw4 = hd44780_write_cmd_raw_gpio4;
	}

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

	platform_set_drvdata(pdev, lcd);
	return 0;

fail3:
	kfree(hd);
fail2:
	kfree(lcd);
fail1:
	kfree(hdc);
	return ret;
}

static int hd44780_remove(struct platform_device *pdev)
{
	struct charlcd *lcd = platform_get_drvdata(pdev);
	struct hd44780_common *hdc = lcd->drvdata;

	charlcd_unregister(lcd);
	kfree(hdc->hd44780);
	kfree(lcd->drvdata);

	kfree(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
75354284	17	#include "charlcd.h"
718e05ed	18	#include "hd44780_common.h"
d47d8836 GU	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
66ce7d5c	41	static void hd44780_backlight(struct charlcd *lcd, enum charlcd_onoff on)
d47d8836	42	{
2545c1c9 LP	43	struct hd44780_common *hdc = lcd->drvdata;
2545c1c9 LP	44	struct hd44780 *hd = hdc->hd44780;
d47d8836 GU	45
	46	if (hd->pins[PIN_CTRL_BL])
	47	gpiod_set_value_cansleep(hd->pins[PIN_CTRL_BL], on);
	48	}
	49
	50	static void hd44780_strobe_gpio(struct hd44780 *hd)
	51	{
	52	/* Maintain the data during 20 us before the strobe */
	53	udelay(20);
	54
	55	gpiod_set_value_cansleep(hd->pins[PIN_CTRL_E], 1);
	56
	57	/* Maintain the strobe during 40 us */
	58	udelay(40);
	59
	60	gpiod_set_value_cansleep(hd->pins[PIN_CTRL_E], 0);
	61	}
	62
	63	/* write to an LCD panel register in 8 bit GPIO mode */
	64	static void hd44780_write_gpio8(struct hd44780 *hd, u8 val, unsigned int rs)
	65	{
b9762beb JK	66	DECLARE_BITMAP(values, 10); /* for DATA[0-7], RS, RW */
	67	unsigned int n;
	68
	69	values[0] = val;
	70	__assign_bit(8, values, rs);
	71	n = hd->pins[PIN_CTRL_RW] ? 10 : 9;
d47d8836 GU	72
d47d8836 GU	73	/* Present the data to the port */
77588c14	74	gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA0], NULL, values);
d47d8836 GU	75
	76	hd44780_strobe_gpio(hd);
	77	}
	78
	79	/* write to an LCD panel register in 4 bit GPIO mode */
	80	static void hd44780_write_gpio4(struct hd44780 *hd, u8 val, unsigned int rs)
	81	{
b9762beb JK	82	DECLARE_BITMAP(values, 6); /* for DATA[4-7], RS, RW */
b9762beb JK	83	unsigned int n;
d47d8836 GU	84
d47d8836 GU	85	/* High nibble + RS, RW */
b9762beb JK	86	values[0] = val >> 4;
	87	__assign_bit(4, values, rs);
	88	n = hd->pins[PIN_CTRL_RW] ? 6 : 5;
d47d8836 GU	89
d47d8836 GU	90	/* Present the data to the port */
77588c14	91	gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], NULL, values);
d47d8836 GU	92
	93	hd44780_strobe_gpio(hd);
	94
	95	/* Low nibble */
b9762beb JK	96	values[0] &= ~0x0fUL;
b9762beb JK	97	values[0] \|= val & 0x0f;
d47d8836 GU	98
d47d8836 GU	99	/* Present the data to the port */
77588c14	100	gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], NULL, values);
d47d8836 GU	101
	102	hd44780_strobe_gpio(hd);
	103	}
	104
	105	/* Send a command to the LCD panel in 8 bit GPIO mode */
2c6a82f2	106	static void hd44780_write_cmd_gpio8(struct hd44780_common *hdc, int cmd)
d47d8836	107	{
2545c1c9	108	struct hd44780 *hd = hdc->hd44780;
d47d8836 GU	109
	110	hd44780_write_gpio8(hd, cmd, 0);
	111
	112	/* The shortest command takes at least 120 us */
	113	udelay(120);
	114	}
	115
	116	/* Send data to the LCD panel in 8 bit GPIO mode */
71ff701b	117	static void hd44780_write_data_gpio8(struct hd44780_common *hdc, int data)
d47d8836	118	{
2545c1c9	119	struct hd44780 *hd = hdc->hd44780;
d47d8836 GU	120
	121	hd44780_write_gpio8(hd, data, 1);
	122
	123	/* The shortest data takes at least 45 us */
	124	udelay(45);
	125	}
	126
	127	static const struct charlcd_ops hd44780_ops_gpio8 = {
d47d8836	128	.backlight = hd44780_backlight,
b26deabb	129	.print = hd44780_common_print,
d3a2fb81	130	.gotoxy = hd44780_common_gotoxy,
88645a86	131	.home = hd44780_common_home,
45421ffe	132	.clear_display = hd44780_common_clear_display,
01ec46df	133	.init_display = hd44780_common_init_display,
d2f2187e LP	134	.shift_cursor = hd44780_common_shift_cursor,
	135	.shift_display = hd44780_common_shift_display,
	136	.display = hd44780_common_display,
	137	.cursor = hd44780_common_cursor,
	138	.blink = hd44780_common_blink,
	139	.fontsize = hd44780_common_fontsize,
	140	.lines = hd44780_common_lines,
339acb08	141	.redefine_char = hd44780_common_redefine_char,
d47d8836 GU	142	};
	143
	144	/* Send a command to the LCD panel in 4 bit GPIO mode */
2c6a82f2	145	static void hd44780_write_cmd_gpio4(struct hd44780_common *hdc, int cmd)
d47d8836	146	{
2545c1c9	147	struct hd44780 *hd = hdc->hd44780;
d47d8836 GU	148
	149	hd44780_write_gpio4(hd, cmd, 0);
	150
	151	/* The shortest command takes at least 120 us */
	152	udelay(120);
	153	}
	154
	155	/* Send 4-bits of a command to the LCD panel in raw 4 bit GPIO mode */
2c6a82f2	156	static void hd44780_write_cmd_raw_gpio4(struct hd44780_common *hdc, int cmd)
d47d8836	157	{
b9762beb	158	DECLARE_BITMAP(values, 6); /* for DATA[4-7], RS, RW */
2545c1c9	159	struct hd44780 *hd = hdc->hd44780;
b9762beb	160	unsigned int n;
d47d8836 GU	161
d47d8836 GU	162	/* Command nibble + RS, RW */
b9762beb JK	163	values[0] = cmd & 0x0f;
b9762beb JK	164	n = hd->pins[PIN_CTRL_RW] ? 6 : 5;
d47d8836 GU	165
d47d8836 GU	166	/* Present the data to the port */
77588c14	167	gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], NULL, values);
d47d8836 GU	168
	169	hd44780_strobe_gpio(hd);
	170	}
	171
	172	/* Send data to the LCD panel in 4 bit GPIO mode */
71ff701b	173	static void hd44780_write_data_gpio4(struct hd44780_common *hdc, int data)
d47d8836	174	{
2545c1c9	175	struct hd44780 *hd = hdc->hd44780;
d47d8836 GU	176
	177	hd44780_write_gpio4(hd, data, 1);
	178
	179	/* The shortest data takes at least 45 us */
	180	udelay(45);
	181	}
	182
	183	static const struct charlcd_ops hd44780_ops_gpio4 = {
d47d8836	184	.backlight = hd44780_backlight,
b26deabb	185	.print = hd44780_common_print,
d3a2fb81	186	.gotoxy = hd44780_common_gotoxy,
88645a86	187	.home = hd44780_common_home,
45421ffe	188	.clear_display = hd44780_common_clear_display,
01ec46df	189	.init_display = hd44780_common_init_display,
d2f2187e LP	190	.shift_cursor = hd44780_common_shift_cursor,
	191	.shift_display = hd44780_common_shift_display,
	192	.display = hd44780_common_display,
	193	.cursor = hd44780_common_cursor,
	194	.blink = hd44780_common_blink,
	195	.fontsize = hd44780_common_fontsize,
	196	.lines = hd44780_common_lines,
339acb08	197	.redefine_char = hd44780_common_redefine_char,
d47d8836 GU	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;
718e05ed	205	struct hd44780_common *hdc;
d47d8836	206	struct hd44780 *hd;
718e05ed	207	int ifwidth, ret = -ENOMEM;
d47d8836 GU	208
	209	/* Required pins */
	210	ifwidth = gpiod_count(dev, "data");
	211	if (ifwidth < 0)
	212	return ifwidth;
	213
	214	switch (ifwidth) {
	215	case 4:
	216	base = PIN_DATA4;
	217	break;
	218	case 8:
	219	base = PIN_DATA0;
	220	break;
	221	default:
	222	return -EINVAL;
	223	}
	224
718e05ed LP	225	hdc = hd44780_common_alloc();
	226	if (!hdc)
	227	return -ENOMEM;
	228
2545c1c9	229	lcd = charlcd_alloc();
d47d8836	230	if (!lcd)
718e05ed	231	goto fail1;
d47d8836	232
718e05ed LP	233	hd = kzalloc(sizeof(struct hd44780), GFP_KERNEL);
	234	if (!hd)
	235	goto fail2;
d47d8836	236
718e05ed LP	237	hdc->hd44780 = hd;
718e05ed LP	238	lcd->drvdata = hdc;
d47d8836 GU	239	for (i = 0; i < ifwidth; i++) {
	240	hd->pins[base + i] = devm_gpiod_get_index(dev, "data", i,
	241	GPIOD_OUT_LOW);
	242	if (IS_ERR(hd->pins[base + i])) {
	243	ret = PTR_ERR(hd->pins[base + i]);
718e05ed	244	goto fail3;
d47d8836 GU	245	}
	246	}
	247
	248	hd->pins[PIN_CTRL_E] = devm_gpiod_get(dev, "enable", GPIOD_OUT_LOW);
	249	if (IS_ERR(hd->pins[PIN_CTRL_E])) {
	250	ret = PTR_ERR(hd->pins[PIN_CTRL_E]);
718e05ed	251	goto fail3;
d47d8836 GU	252	}
	253
	254	hd->pins[PIN_CTRL_RS] = devm_gpiod_get(dev, "rs", GPIOD_OUT_HIGH);
	255	if (IS_ERR(hd->pins[PIN_CTRL_RS])) {
	256	ret = PTR_ERR(hd->pins[PIN_CTRL_RS]);
718e05ed	257	goto fail3;
d47d8836 GU	258	}
	259
	260	/* Optional pins */
	261	hd->pins[PIN_CTRL_RW] = devm_gpiod_get_optional(dev, "rw",
	262	GPIOD_OUT_LOW);
	263	if (IS_ERR(hd->pins[PIN_CTRL_RW])) {
	264	ret = PTR_ERR(hd->pins[PIN_CTRL_RW]);
718e05ed	265	goto fail3;
d47d8836 GU	266	}
	267
	268	hd->pins[PIN_CTRL_BL] = devm_gpiod_get_optional(dev, "backlight",
	269	GPIOD_OUT_LOW);
	270	if (IS_ERR(hd->pins[PIN_CTRL_BL])) {
	271	ret = PTR_ERR(hd->pins[PIN_CTRL_BL]);
718e05ed	272	goto fail3;
d47d8836 GU	273	}
	274
	275	/* Required properties */
c7c3f096 GU	276	ret = device_property_read_u32(dev, "display-height-chars",
c7c3f096 GU	277	&lcd->height);
d47d8836	278	if (ret)
718e05ed	279	goto fail3;
c7c3f096	280	ret = device_property_read_u32(dev, "display-width-chars", &lcd->width);
d47d8836	281	if (ret)
718e05ed	282	goto fail3;
d47d8836 GU	283
	284	/*
	285	* On displays with more than two rows, the internal buffer width is
	286	* usually equal to the display width
	287	*/
	288	if (lcd->height > 2)
2545c1c9	289	hdc->bwidth = lcd->width;
d47d8836 GU	290
d47d8836 GU	291	/* Optional properties */
2545c1c9	292	device_property_read_u32(dev, "internal-buffer-width", &hdc->bwidth);
d47d8836	293
3fc04dd7	294	hdc->ifwidth = ifwidth;
71ff701b LP	295	if (ifwidth == 8) {
	296	lcd->ops = &hd44780_ops_gpio8;
	297	hdc->write_data = hd44780_write_data_gpio8;
2c6a82f2	298	hdc->write_cmd = hd44780_write_cmd_gpio8;
71ff701b LP	299	} else {
	300	lcd->ops = &hd44780_ops_gpio4;
	301	hdc->write_data = hd44780_write_data_gpio4;
2c6a82f2 LP	302	hdc->write_cmd = hd44780_write_cmd_gpio4;
2c6a82f2 LP	303	hdc->write_cmd_raw4 = hd44780_write_cmd_raw_gpio4;
71ff701b	304	}
d47d8836 GU	305
	306	ret = charlcd_register(lcd);
	307	if (ret)
718e05ed	308	goto fail3;
d47d8836 GU	309
	310	platform_set_drvdata(pdev, lcd);
	311	return 0;
	312
718e05ed LP	313	fail3:
	314	kfree(hd);
	315	fail2:
	316	kfree(lcd);
	317	fail1:
	318	kfree(hdc);
d47d8836 GU	319	return ret;
	320	}
	321
	322	static int hd44780_remove(struct platform_device *pdev)
	323	{
	324	struct charlcd *lcd = platform_get_drvdata(pdev);
ddf75a86	325	struct hd44780_common *hdc = lcd->drvdata;
d47d8836 GU	326
d47d8836 GU	327	charlcd_unregister(lcd);
ddf75a86	328	kfree(hdc->hd44780);
333ff32d	329	kfree(lcd->drvdata);
41c8d0ad	330
718e05ed	331	kfree(lcd);
d47d8836 GU	332	return 0;
	333	}
	334
	335	static const struct of_device_id hd44780_of_match[] = {
	336	{ .compatible = "hit,hd44780" },
	337	{ /* sentinel */ }
	338	};
	339	MODULE_DEVICE_TABLE(of, hd44780_of_match);
	340
	341	static struct platform_driver hd44780_driver = {
	342	.probe = hd44780_probe,
	343	.remove = hd44780_remove,
	344	.driver = {
	345	.name = "hd44780",
	346	.of_match_table = hd44780_of_match,
	347	},
	348	};
	349
	350	module_platform_driver(hd44780_driver);
	351	MODULE_DESCRIPTION("HD44780 Character LCD driver");
	352	MODULE_AUTHOR("Geert Uytterhoeven <geert@linux-m68k.org>");
	353	MODULE_LICENSE("GPL");