Commit | Line | Data |
---|---|---|
8c9108d0 LP |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* | |
3 | * console driver for LCD2S 4x20 character displays connected through i2c. | |
4 | * The display also has a spi interface, but the driver does not support | |
5 | * this yet. | |
6 | * | |
7 | * This is a driver allowing you to use a LCD2S 4x20 from modtronix | |
8 | * engineering as auxdisplay character device. | |
9 | * | |
10 | * (C) 2019 by Lemonage Software GmbH | |
11 | * Author: Lars Pöschel <poeschel@lemonage.de> | |
12 | * All rights reserved. | |
13 | */ | |
14 | #include <linux/kernel.h> | |
15 | #include <linux/module.h> | |
16 | #include <linux/slab.h> | |
17 | #include <linux/i2c.h> | |
18 | #include <linux/delay.h> | |
19 | ||
20 | #include "charlcd.h" | |
21 | ||
22 | #define LCD2S_CMD_CUR_MOVES_FWD 0x09 | |
23 | #define LCD2S_CMD_CUR_BLINK_OFF 0x10 | |
24 | #define LCD2S_CMD_CUR_UL_OFF 0x11 | |
25 | #define LCD2S_CMD_DISPLAY_OFF 0x12 | |
26 | #define LCD2S_CMD_CUR_BLINK_ON 0x18 | |
27 | #define LCD2S_CMD_CUR_UL_ON 0x19 | |
28 | #define LCD2S_CMD_DISPLAY_ON 0x1a | |
29 | #define LCD2S_CMD_BACKLIGHT_OFF 0x20 | |
30 | #define LCD2S_CMD_BACKLIGHT_ON 0x28 | |
31 | #define LCD2S_CMD_WRITE 0x80 | |
32 | #define LCD2S_CMD_MOV_CUR_RIGHT 0x83 | |
33 | #define LCD2S_CMD_MOV_CUR_LEFT 0x84 | |
34 | #define LCD2S_CMD_SHIFT_RIGHT 0x85 | |
35 | #define LCD2S_CMD_SHIFT_LEFT 0x86 | |
36 | #define LCD2S_CMD_SHIFT_UP 0x87 | |
37 | #define LCD2S_CMD_SHIFT_DOWN 0x88 | |
38 | #define LCD2S_CMD_CUR_ADDR 0x89 | |
39 | #define LCD2S_CMD_CUR_POS 0x8a | |
40 | #define LCD2S_CMD_CUR_RESET 0x8b | |
41 | #define LCD2S_CMD_CLEAR 0x8c | |
42 | #define LCD2S_CMD_DEF_CUSTOM_CHAR 0x92 | |
43 | #define LCD2S_CMD_READ_STATUS 0xd0 | |
44 | ||
45 | #define LCD2S_CHARACTER_SIZE 8 | |
46 | ||
47 | #define LCD2S_STATUS_BUF_MASK 0x7f | |
48 | ||
49 | struct lcd2s_data { | |
50 | struct i2c_client *i2c; | |
51 | struct charlcd *charlcd; | |
52 | }; | |
53 | ||
54 | static s32 lcd2s_wait_buf_free(const struct i2c_client *client, int count) | |
55 | { | |
56 | s32 status; | |
57 | ||
58 | status = i2c_smbus_read_byte_data(client, LCD2S_CMD_READ_STATUS); | |
59 | if (status < 0) | |
60 | return status; | |
61 | ||
62 | while ((status & LCD2S_STATUS_BUF_MASK) < count) { | |
63 | mdelay(1); | |
64 | status = i2c_smbus_read_byte_data(client, | |
65 | LCD2S_CMD_READ_STATUS); | |
66 | if (status < 0) | |
67 | return status; | |
68 | } | |
69 | return 0; | |
70 | } | |
71 | ||
72 | static int lcd2s_i2c_master_send(const struct i2c_client *client, | |
73 | const char *buf, int count) | |
74 | { | |
75 | s32 status; | |
76 | ||
77 | status = lcd2s_wait_buf_free(client, count); | |
78 | if (status < 0) | |
79 | return status; | |
80 | ||
81 | return i2c_master_send(client, buf, count); | |
82 | } | |
83 | ||
84 | static int lcd2s_i2c_smbus_write_byte(const struct i2c_client *client, u8 value) | |
85 | { | |
86 | s32 status; | |
87 | ||
88 | status = lcd2s_wait_buf_free(client, 1); | |
89 | if (status < 0) | |
90 | return status; | |
91 | ||
92 | return i2c_smbus_write_byte(client, value); | |
93 | } | |
94 | ||
95 | static int lcd2s_print(struct charlcd *lcd, int c) | |
96 | { | |
97 | struct lcd2s_data *lcd2s = lcd->drvdata; | |
98 | u8 buf[2] = { LCD2S_CMD_WRITE, c }; | |
99 | ||
100 | lcd2s_i2c_master_send(lcd2s->i2c, buf, sizeof(buf)); | |
101 | return 0; | |
102 | } | |
103 | ||
104 | static int lcd2s_gotoxy(struct charlcd *lcd, unsigned int x, unsigned int y) | |
105 | { | |
106 | struct lcd2s_data *lcd2s = lcd->drvdata; | |
107 | u8 buf[] = { LCD2S_CMD_CUR_POS, y + 1, x + 1}; | |
108 | ||
109 | lcd2s_i2c_master_send(lcd2s->i2c, buf, sizeof(buf)); | |
110 | ||
111 | return 0; | |
112 | } | |
113 | ||
114 | static int lcd2s_home(struct charlcd *lcd) | |
115 | { | |
116 | struct lcd2s_data *lcd2s = lcd->drvdata; | |
117 | ||
118 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_RESET); | |
119 | return 0; | |
120 | } | |
121 | ||
122 | static int lcd2s_init_display(struct charlcd *lcd) | |
123 | { | |
124 | struct lcd2s_data *lcd2s = lcd->drvdata; | |
125 | ||
126 | /* turn everything off, but display on */ | |
127 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_DISPLAY_ON); | |
128 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_BACKLIGHT_OFF); | |
129 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_MOVES_FWD); | |
130 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_BLINK_OFF); | |
131 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_UL_OFF); | |
132 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CLEAR); | |
133 | ||
134 | return 0; | |
135 | } | |
136 | ||
137 | static int lcd2s_shift_cursor(struct charlcd *lcd, enum charlcd_shift_dir dir) | |
138 | { | |
139 | struct lcd2s_data *lcd2s = lcd->drvdata; | |
140 | ||
141 | if (dir == CHARLCD_SHIFT_LEFT) | |
142 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_MOV_CUR_LEFT); | |
143 | else | |
144 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_MOV_CUR_RIGHT); | |
145 | ||
146 | return 0; | |
147 | } | |
148 | ||
149 | static int lcd2s_shift_display(struct charlcd *lcd, enum charlcd_shift_dir dir) | |
150 | { | |
151 | struct lcd2s_data *lcd2s = lcd->drvdata; | |
152 | ||
153 | if (dir == CHARLCD_SHIFT_LEFT) | |
154 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_SHIFT_LEFT); | |
155 | else | |
156 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_SHIFT_RIGHT); | |
157 | ||
158 | return 0; | |
159 | } | |
160 | ||
161 | static void lcd2s_backlight(struct charlcd *lcd, enum charlcd_onoff on) | |
162 | { | |
163 | struct lcd2s_data *lcd2s = lcd->drvdata; | |
164 | ||
165 | if (on) | |
166 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_BACKLIGHT_ON); | |
167 | else | |
168 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_BACKLIGHT_OFF); | |
169 | } | |
170 | ||
171 | static int lcd2s_display(struct charlcd *lcd, enum charlcd_onoff on) | |
172 | { | |
173 | struct lcd2s_data *lcd2s = lcd->drvdata; | |
174 | ||
175 | if (on) | |
176 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_DISPLAY_ON); | |
177 | else | |
178 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_DISPLAY_OFF); | |
179 | ||
180 | return 0; | |
181 | } | |
182 | ||
183 | static int lcd2s_cursor(struct charlcd *lcd, enum charlcd_onoff on) | |
184 | { | |
185 | struct lcd2s_data *lcd2s = lcd->drvdata; | |
186 | ||
187 | if (on) | |
188 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_UL_ON); | |
189 | else | |
190 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_UL_OFF); | |
191 | ||
192 | return 0; | |
193 | } | |
194 | ||
195 | static int lcd2s_blink(struct charlcd *lcd, enum charlcd_onoff on) | |
196 | { | |
197 | struct lcd2s_data *lcd2s = lcd->drvdata; | |
198 | ||
199 | if (on) | |
200 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_BLINK_ON); | |
201 | else | |
202 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_BLINK_OFF); | |
203 | ||
204 | return 0; | |
205 | } | |
206 | ||
207 | static int lcd2s_fontsize(struct charlcd *lcd, enum charlcd_fontsize size) | |
208 | { | |
209 | return 0; | |
210 | } | |
211 | ||
212 | static int lcd2s_lines(struct charlcd *lcd, enum charlcd_lines lines) | |
213 | { | |
214 | return 0; | |
215 | } | |
216 | ||
217 | static int lcd2s_redefine_char(struct charlcd *lcd, char *esc) | |
218 | { | |
219 | /* Generator : LGcxxxxx...xx; must have <c> between '0' | |
220 | * and '7', representing the numerical ASCII code of the | |
221 | * redefined character, and <xx...xx> a sequence of 16 | |
222 | * hex digits representing 8 bytes for each character. | |
223 | * Most LCDs will only use 5 lower bits of the 7 first | |
224 | * bytes. | |
225 | */ | |
226 | ||
227 | struct lcd2s_data *lcd2s = lcd->drvdata; | |
228 | u8 buf[LCD2S_CHARACTER_SIZE + 2] = { LCD2S_CMD_DEF_CUSTOM_CHAR }; | |
229 | u8 value; | |
230 | int shift, i; | |
231 | ||
232 | if (!strchr(esc, ';')) | |
233 | return 0; | |
234 | ||
235 | esc++; | |
236 | ||
237 | buf[1] = *(esc++) - '0'; | |
238 | if (buf[1] > 7) | |
239 | return 1; | |
240 | ||
241 | i = 0; | |
242 | shift = 0; | |
243 | value = 0; | |
244 | while (*esc && i < LCD2S_CHARACTER_SIZE + 2) { | |
245 | int half; | |
246 | ||
247 | shift ^= 4; | |
248 | half = hex_to_bin(*esc++); | |
249 | if (half < 0) | |
250 | continue; | |
251 | ||
252 | value |= half << shift; | |
253 | if (shift == 0) { | |
254 | buf[i++] = value; | |
255 | value = 0; | |
256 | } | |
257 | } | |
258 | ||
259 | lcd2s_i2c_master_send(lcd2s->i2c, buf, sizeof(buf)); | |
260 | return 1; | |
261 | } | |
262 | ||
263 | static int lcd2s_clear_display(struct charlcd *lcd) | |
264 | { | |
265 | struct lcd2s_data *lcd2s = lcd->drvdata; | |
266 | ||
267 | /* This implicitly sets cursor to first row and column */ | |
268 | lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CLEAR); | |
269 | return 0; | |
270 | } | |
271 | ||
272 | static const struct charlcd_ops lcd2s_ops = { | |
273 | .print = lcd2s_print, | |
274 | .backlight = lcd2s_backlight, | |
275 | .gotoxy = lcd2s_gotoxy, | |
276 | .home = lcd2s_home, | |
277 | .clear_display = lcd2s_clear_display, | |
278 | .init_display = lcd2s_init_display, | |
279 | .shift_cursor = lcd2s_shift_cursor, | |
280 | .shift_display = lcd2s_shift_display, | |
281 | .display = lcd2s_display, | |
282 | .cursor = lcd2s_cursor, | |
283 | .blink = lcd2s_blink, | |
284 | .fontsize = lcd2s_fontsize, | |
285 | .lines = lcd2s_lines, | |
286 | .redefine_char = lcd2s_redefine_char, | |
287 | }; | |
288 | ||
289 | static int lcd2s_i2c_probe(struct i2c_client *i2c, | |
290 | const struct i2c_device_id *id) | |
291 | { | |
292 | struct charlcd *lcd; | |
293 | struct lcd2s_data *lcd2s; | |
294 | int err; | |
295 | ||
296 | if (!i2c_check_functionality(i2c->adapter, | |
297 | I2C_FUNC_SMBUS_WRITE_BYTE_DATA | | |
298 | I2C_FUNC_SMBUS_WRITE_BLOCK_DATA)) | |
299 | return -EIO; | |
300 | ||
301 | /* Test, if the display is responding */ | |
302 | err = lcd2s_i2c_smbus_write_byte(i2c, LCD2S_CMD_DISPLAY_OFF); | |
303 | if (err < 0) | |
304 | return err; | |
305 | ||
306 | lcd = charlcd_alloc(); | |
307 | if (!lcd) | |
308 | return -ENOMEM; | |
309 | ||
310 | lcd2s = kzalloc(sizeof(struct lcd2s_data), GFP_KERNEL); | |
311 | if (!lcd2s) { | |
312 | err = -ENOMEM; | |
313 | goto fail1; | |
314 | } | |
315 | ||
316 | lcd->drvdata = lcd2s; | |
317 | lcd2s->i2c = i2c; | |
318 | lcd2s->charlcd = lcd; | |
319 | ||
320 | /* Required properties */ | |
321 | err = device_property_read_u32(&i2c->dev, "display-height-chars", | |
322 | &lcd->height); | |
323 | if (err) | |
324 | goto fail2; | |
325 | ||
326 | err = device_property_read_u32(&i2c->dev, "display-width-chars", | |
327 | &lcd->width); | |
328 | if (err) | |
329 | goto fail2; | |
330 | ||
331 | lcd->ops = &lcd2s_ops; | |
332 | ||
333 | err = charlcd_register(lcd2s->charlcd); | |
334 | if (err) | |
335 | goto fail2; | |
336 | ||
337 | i2c_set_clientdata(i2c, lcd2s); | |
338 | return 0; | |
339 | ||
340 | fail2: | |
341 | kfree(lcd2s); | |
342 | fail1: | |
343 | kfree(lcd); | |
344 | return err; | |
345 | } | |
346 | ||
347 | static int lcd2s_i2c_remove(struct i2c_client *i2c) | |
348 | { | |
349 | struct lcd2s_data *lcd2s = i2c_get_clientdata(i2c); | |
350 | ||
8c9108d0 | 351 | charlcd_unregister(lcd2s->charlcd); |
2cfd72f8 | 352 | kfree(lcd2s->charlcd); |
8c9108d0 LP |
353 | return 0; |
354 | } | |
355 | ||
356 | static const struct i2c_device_id lcd2s_i2c_id[] = { | |
357 | { "lcd2s", 0 }, | |
358 | { } | |
359 | }; | |
360 | MODULE_DEVICE_TABLE(i2c, lcd2s_i2c_id); | |
361 | ||
362 | #ifdef CONFIG_OF | |
363 | static const struct of_device_id lcd2s_of_table[] = { | |
364 | { .compatible = "modtronix,lcd2s" }, | |
365 | { } | |
366 | }; | |
367 | MODULE_DEVICE_TABLE(of, lcd2s_of_table); | |
368 | #endif | |
369 | ||
370 | static struct i2c_driver lcd2s_i2c_driver = { | |
371 | .driver = { | |
372 | .name = "lcd2s", | |
8c9108d0 LP |
373 | #ifdef CONFIG_OF |
374 | .of_match_table = of_match_ptr(lcd2s_of_table), | |
375 | #endif | |
376 | }, | |
377 | .probe = lcd2s_i2c_probe, | |
378 | .remove = lcd2s_i2c_remove, | |
379 | .id_table = lcd2s_i2c_id, | |
380 | }; | |
381 | ||
382 | static int __init lcd2s_modinit(void) | |
383 | { | |
384 | int ret = 0; | |
385 | ||
386 | ret = i2c_add_driver(&lcd2s_i2c_driver); | |
387 | if (ret != 0) | |
388 | pr_err("Failed to register lcd2s driver\n"); | |
389 | ||
390 | return ret; | |
391 | } | |
392 | module_init(lcd2s_modinit) | |
393 | ||
394 | static void __exit lcd2s_exit(void) | |
395 | { | |
396 | i2c_del_driver(&lcd2s_i2c_driver); | |
397 | } | |
398 | module_exit(lcd2s_exit) | |
399 | ||
400 | MODULE_DESCRIPTION("LCD2S character display driver"); | |
401 | MODULE_AUTHOR("Lars Poeschel"); | |
402 | MODULE_LICENSE("GPL"); |