Fix the bug related to the empty version list
[bertos.git] / bertos / drv / lcd_text.c
1 /**
2  * \file
3  * <!--
4  * This file is part of BeRTOS.
5  *
6  * Bertos is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  * As a special exception, you may use this file as part of a free software
21  * library without restriction.  Specifically, if other files instantiate
22  * templates or use macros or inline functions from this file, or you compile
23  * this file and link it with other files to produce an executable, this
24  * file does not by itself cause the resulting executable to be covered by
25  * the GNU General Public License.  This exception does not however
26  * invalidate any other reasons why the executable file might be covered by
27  * the GNU General Public License.
28  *
29  * Copyright 2005 Develer S.r.l. (http://www.develer.com/)
30  * All Rights Reserved.
31  * -->
32  *
33  * \brief Generic text LCD driver (impl.).
34  *
35  * \version $Id$
36  * \author Bernie Innocenti <bernie@codewiz.org>
37  * \author Stefano Fedrigo <aleph@develer.com>
38  */
39
40 #include "lcd_text.h"
41 #include "lcd_hd44.h"
42
43 #include <cfg/macros.h> // BV()
44 #include <cfg/debug.h>
45
46 #include <drv/timer.h> // timer_delay()
47
48 #include <mware/formatwr.h> // _formatted_write()
49 #include <struct/list.h> // LIST_EMPTY()
50
51 #include <string.h> // strlen()
52
53
54 /** Maximum number of layers. */
55 #define LCD_LAYERS 6
56
57 #if CONFIG_KERN
58         #include <kern/sem.h>
59         /** Semaphore to arbitrate access to the display. */
60         static struct Semaphore lcd_semaphore;
61         #define LOCK_LCD        sem_obtain(&lcd_semaphore)
62         #define UNLOCK_LCD      sem_release(&lcd_semaphore)
63 #else /* !CONFIG_KERN */
64         #define LOCK_LCD        do {} while (0)
65         #define UNLOCK_LCD      do {} while (0)
66 #endif /* !CONFIG_KERN */
67
68 DECLARE_LIST_TYPE(Layer);
69
70 Layer *lcd_DefLayer;
71 static Layer lcd_LayersPool[LCD_LAYERS];
72 static LIST_TYPE(Layer) lcd_Layers;
73 static LIST_TYPE(Layer) lcd_FreeLayers;
74
75 /**
76  * Current cursor status.
77  *
78  * One of LCD_CMD_CURSOR_OFF, LCD_CMD_CURSOR_BLOCK or LCD_CMD_CURSOR_LINE.
79  */
80 static uint8_t lcd_CursorStatus;
81
82 /** Current cursor position, encoded as a Cursor position and status. */
83 static lcdpos_t lcd_CursorAddr;
84
85
86 void lcd_setAddr(Layer *layer, lcdpos_t addr)
87 {
88         /* Sanity check: wrap around to display limits */
89         while (addr >= LCD_ROWS * LCD_COLS)
90                 addr -= LCD_ROWS * LCD_COLS;
91
92         layer->addr = addr;
93 }
94
95 #if CONFIG_KERN
96
97 void lcd_lock(void)
98 {
99         LOCK_LCD;
100 }
101
102
103 void lcd_unlock(void)
104 {
105         UNLOCK_LCD;
106 }
107
108 #endif /* CONFIG_KERN */
109
110
111 /**
112  * Write one character to the display at the current
113  * cursor prosition, then move the cursor right. The
114  * cursor is wrapped to the next line when it moves
115  * beyond the end of the current line.
116  *
117  * \note Does _NOT_ lock the display semaphore.
118  */
119 static void lcd_putCharUnlocked(char c, Layer *layer)
120 {
121         Layer *l2;
122         lcdpos_t addr = layer->addr;
123
124         /* Store character in layer buffer */
125         layer->buf[addr] = c;
126
127         /* Move to next character */
128         if (++layer->addr >= LCD_COLS * LCD_ROWS)
129                 layer->addr = 0;
130
131         /* Do not write on LCD if layer is hidden. */
132         if (layer->pri == LAYER_HIDDEN)
133                 return;
134
135         /*
136          * Check if this location is obscured by
137          * other layers above us.
138          */
139         for (l2 = layer->pred; l2->pred; l2 = l2->pred)
140         {
141                 if (l2->buf[addr])
142                 {
143                         /* DB(kprintf("layer %04x obs %04x at %d\n", l2, layer, addr);) */
144                         return;
145                 }
146         }
147
148         /* Write character */
149         if (c)
150                 lcd_putc(addr, c);
151         else
152                 /* FIXME: should look for layers beneath! */
153                 lcd_putc(addr, ' ');
154 }
155
156
157 void lcd_putChar(char c, Layer *layer)
158 {
159         LOCK_LCD;
160         lcd_putCharUnlocked(c, layer);
161         UNLOCK_LCD;
162 }
163
164 void lcd_layerSet(Layer *layer, char c)
165 {
166         int i;
167
168         LOCK_LCD;
169         lcd_setAddr(layer, 0);
170         for (i = 0; i < LCD_COLS * LCD_ROWS; i++)
171                 lcd_putCharUnlocked(c, layer);
172         UNLOCK_LCD;
173 }
174
175
176 void lcd_clear(Layer *layer)
177 {
178         lcd_layerSet(layer, 0);
179 }
180
181
182 void lcd_clearLine(Layer *layer, int y)
183 {
184         int i;
185
186         LOCK_LCD;
187         lcd_setAddr(layer, LCD_POS(0, y));
188         for (i = 0; i < LCD_COLS; i++)
189                 lcd_putCharUnlocked(0, layer);
190         UNLOCK_LCD;
191 }
192
193
194 void lcd_moveCursor(lcdpos_t addr)
195 {
196         LOCK_LCD;
197         lcd_moveTo(addr);
198         UNLOCK_LCD;
199 }
200
201
202 char lcd_setCursor(char mode)
203 {
204         static const char cursor_cmd[3] =
205         {
206                 LCD_CMD_CURSOR_OFF, LCD_CMD_CURSOR_BLOCK, LCD_CMD_CURSOR_LINE
207         };
208         char oldmode = lcd_CursorStatus;
209
210         LOCK_LCD;
211         lcd_CursorStatus = mode;
212         lcd_setReg(cursor_cmd[(int)mode]);
213         if (mode)
214                 lcd_moveCursor(lcd_CursorAddr);
215         UNLOCK_LCD;
216
217         return oldmode;
218 }
219
220
221 int lcd_vprintf(Layer *layer, lcdpos_t addr, uint8_t mode, const char *format, va_list ap)
222 {
223         int len;
224
225         LOCK_LCD;
226
227         /*
228          * Se il cursore era acceso, spegnilo durante
229          * l'output per evitare che salti alla posizione
230          * in cui si scrive.
231          */
232         if (lcd_CursorStatus)
233                 lcd_setReg(LCD_CMD_CURSOR_OFF);
234
235         /* Spostamento del cursore */
236         lcd_setAddr(layer, addr);
237
238         if (mode & LCD_CENTER)
239         {
240                 int pad;
241
242                 /*
243                  * NOTE: calculating the string lenght BEFORE it gets
244                  * printf()-formatted. Real lenght may differ.
245                  */
246                 pad = (LCD_COLS - strlen(format)) / 2;
247                 while (pad--)
248                         lcd_putCharUnlocked(' ', layer);
249         }
250
251         len = _formatted_write(format, (void (*)(char, void *))lcd_putCharUnlocked, layer, ap);
252
253         if (mode & (LCD_FILL | LCD_CENTER))
254                 while (layer->addr % LCD_COLS)
255                         lcd_putCharUnlocked(' ', layer);
256
257         /*
258          * Riaccendi il cursore e riportalo alla
259          * vecchia posizione
260          */
261         if (lcd_CursorStatus)
262                 lcd_setCursor(lcd_CursorStatus);
263
264         UNLOCK_LCD;
265
266         return len;
267 }
268
269
270 int lcd_printf(Layer *layer, lcdpos_t addr, uint8_t mode, const char *format, ...)
271 {
272         int len;
273         va_list ap;
274
275         va_start(ap, format);
276         len = lcd_vprintf(layer, addr, mode, format, ap);
277         va_end(ap);
278
279         return len;
280 }
281
282
283 /**
284  * Internal function to move a layer between two positions.
285  *
286  * \note The layer must be *already* enqueued in some list.
287  * \note The display must be already locked!
288  */
289 static void lcd_enqueueLayer(Layer *layer, char pri)
290 {
291         Layer *l2;
292
293         /* Remove layer from whatever list it was in before */
294         REMOVE(layer);
295
296         layer->pri = pri;
297
298         /*
299          * Search for the first layer whose priority
300          * is less or equal to the layer we are adding.
301          */
302         FOREACH_NODE(l2, &lcd_Layers)
303                 if (l2->pri <= pri)
304                         break;
305
306         /* Enqueue layer */
307         INSERT_BEFORE(layer, l2);
308 }
309
310 Layer *lcd_newLayer(char pri)
311 {
312         Layer *layer;
313
314         LOCK_LCD;
315
316         if (LIST_EMPTY(&lcd_FreeLayers))
317         {
318                 UNLOCK_LCD;
319                 //ASSERT(false);
320                 return NULL;
321         }
322
323         layer = (Layer *)LIST_HEAD(&lcd_FreeLayers);
324         layer->addr = 0;
325         memset(layer->buf, 0, LCD_ROWS * LCD_COLS);
326
327         lcd_enqueueLayer(layer, pri);
328
329         UNLOCK_LCD;
330         return layer;
331 }
332
333 /**
334  * Redraw the display (internal).
335  *
336  * \note The display must be already locked.
337  */
338 static void lcd_refresh(void)
339 {
340         lcdpos_t addr;
341         Layer *l;
342
343         for (addr = 0; addr < LCD_ROWS * LCD_COLS; ++addr)
344         {
345                 FOREACH_NODE(l, &lcd_Layers)
346                 {
347                         //kprintf("%d %x %p\n", addr, l->buf[0], l);
348                         if (l->pri == LAYER_HIDDEN)
349                                 break;
350
351                         if (l->buf[addr])
352                         {
353                                 /* Refresh location */
354                                 lcd_putc(addr, l->buf[addr]);
355                                 goto done;
356                         }
357                 }
358
359                 /* Draw background */
360                 lcd_putc(addr, ' ');
361         done:
362                 ;
363         }
364 }
365
366 /**
367  * Rearrange layer depth and refresh display accordingly.
368  *
369  * \note Setting a priority of LAYER_HIDDEN makes the layer invisible.
370  */
371 void lcd_setLayerDepth(Layer *layer, char pri)
372 {
373         if (pri != layer->pri)
374         {
375                 LOCK_LCD;
376                 lcd_enqueueLayer(layer, pri);
377                 /* Vile but simple */
378                 lcd_refresh();
379                 UNLOCK_LCD;
380         }
381 }
382
383 void lcd_deleteLayer(Layer *layer)
384 {
385         LOCK_LCD;
386
387 /* We use lcd_refresh() instead.  Much simpler than this mess, but slower. */
388 #if 0
389         Layer *l2;
390         lcdpos_t addr;
391
392         /* Repair damage on underlaying layers */
393         for (addr = 0; addr < LCD_ROWS * LCD_COLS; ++addr)
394         {
395                 /* If location was covered by us */
396                 if (layer->buf[addr])
397                 {
398                         /* ...and it wasn't covered by others above us... */
399                         for (l2 = layer->pred; l2->pred; l2 = l2->pred)
400                                 if (l2->buf[addr])
401                                         /* can't just break here! */
402                                         goto not_visible;
403
404                         /* ...scan underlaying layers to repair damage */
405                         for (l2 = layer->succ; l2->succ; l2 = l2->succ)
406                                 if (l2->buf[addr])
407                                 {
408                                         /* Refresh character */
409                                         lcd_putc(addr, l2->buf[addr]);
410
411                                         /* No need to search on deeper layers */
412                                         break;
413                                 }
414
415                         not_visible:
416                                 ;
417                 }
418         }
419 #endif
420
421         // Remove layer from lcd_Layers list.
422         REMOVE(layer);
423
424         /* Put layer back into free list */
425         ADDHEAD(&lcd_FreeLayers, layer);
426
427         lcd_refresh();
428
429         UNLOCK_LCD;
430 }
431
432
433 static void lcd_setDefLayer(Layer *layer)
434 {
435         lcd_DefLayer = layer;
436 }
437
438 #include <cfg/debug.h>
439 void lcd_init(void)
440 {
441         int i;
442
443         LIST_INIT(&lcd_Layers);
444         LIST_INIT(&lcd_FreeLayers);
445         for (i = 0; i < LCD_LAYERS; ++i)
446                 ADDHEAD(&lcd_FreeLayers, &lcd_LayersPool[i]);
447
448         lcd_setDefLayer(lcd_newLayer(0));
449
450         lcd_hw_init();
451
452         lcd_setCursor(0);
453 }
454
455