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