]> git.sur5r.net Git - u-boot/blob - drivers/video/console_rotate.c
arm: imx6ul: Add Engicam GEAM6UL Starter Kit initial support
[u-boot] / drivers / video / console_rotate.c
1 /*
2  * Copyright (c) 2015 Google, Inc
3  * (C) Copyright 2015
4  * Bernecker & Rainer Industrieelektronik GmbH - http://www.br-automation.com
5  *
6  * SPDX-License-Identifier:     GPL-2.0+
7  */
8
9 #include <common.h>
10 #include <dm.h>
11 #include <video.h>
12 #include <video_console.h>
13 #include <video_font.h>         /* Get font data, width and height */
14
15 static int console_set_row_1(struct udevice *dev, uint row, int clr)
16 {
17         struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
18         int pbytes = VNBYTES(vid_priv->bpix);
19         void *line;
20         int i, j;
21
22         line = vid_priv->fb + vid_priv->line_length -
23                 (row + 1) * VIDEO_FONT_HEIGHT * pbytes;
24         for (j = 0; j < vid_priv->ysize; j++) {
25                 switch (vid_priv->bpix) {
26 #ifdef CONFIG_VIDEO_BPP8
27                 case VIDEO_BPP8: {
28                         uint8_t *dst = line;
29
30                         for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
31                                 *dst++ = clr;
32                         break;
33                 }
34 #endif
35 #ifdef CONFIG_VIDEO_BPP16
36                 case VIDEO_BPP16: {
37                         uint16_t *dst = line;
38
39                         for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
40                                 *dst++ = clr;
41                         break;
42                 }
43 #endif
44 #ifdef CONFIG_VIDEO_BPP32
45                 case VIDEO_BPP32: {
46                         uint32_t *dst = line;
47
48                         for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
49                                 *dst++ = clr;
50                         break;
51                 }
52 #endif
53                 default:
54                         return -ENOSYS;
55                 }
56                 line += vid_priv->line_length;
57         }
58
59         return 0;
60 }
61
62 static int console_move_rows_1(struct udevice *dev, uint rowdst, uint rowsrc,
63                                uint count)
64 {
65         struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
66         void *dst;
67         void *src;
68         int pbytes = VNBYTES(vid_priv->bpix);
69         int j;
70
71         dst = vid_priv->fb + vid_priv->line_length -
72                 (rowdst + count) * VIDEO_FONT_HEIGHT * pbytes;
73         src = vid_priv->fb + vid_priv->line_length -
74                 (rowsrc + count) * VIDEO_FONT_HEIGHT * pbytes;
75
76         for (j = 0; j < vid_priv->ysize; j++) {
77                 memmove(dst, src, VIDEO_FONT_HEIGHT * pbytes * count);
78                 src += vid_priv->line_length;
79                 dst += vid_priv->line_length;
80         }
81
82         return 0;
83 }
84
85 static int console_putc_xy_1(struct udevice *dev, uint x_frac, uint y, char ch)
86 {
87         struct vidconsole_priv *vc_priv = dev_get_uclass_priv(dev);
88         struct udevice *vid = dev->parent;
89         struct video_priv *vid_priv = dev_get_uclass_priv(vid);
90         int pbytes = VNBYTES(vid_priv->bpix);
91         int i, col;
92         int mask = 0x80;
93         void *line;
94         uchar *pfont = video_fontdata + ch * VIDEO_FONT_HEIGHT;
95
96         line = vid_priv->fb + (VID_TO_PIXEL(x_frac) + 1) *
97                         vid_priv->line_length - (y + 1) * pbytes;
98         if (x_frac + VID_TO_POS(vc_priv->x_charsize) > vc_priv->xsize_frac)
99                 return -EAGAIN;
100
101         for (col = 0; col < VIDEO_FONT_HEIGHT; col++) {
102                 switch (vid_priv->bpix) {
103 #ifdef CONFIG_VIDEO_BPP8
104                 case VIDEO_BPP8: {
105                         uint8_t *dst = line;
106
107                         for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
108                                 *dst-- = (pfont[i] & mask) ? vid_priv->colour_fg
109                                         : vid_priv->colour_bg;
110                         }
111                         break;
112                 }
113 #endif
114 #ifdef CONFIG_VIDEO_BPP16
115                 case VIDEO_BPP16: {
116                         uint16_t *dst = line;
117
118                         for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
119                                 *dst-- = (pfont[i] & mask) ? vid_priv->colour_fg
120                                         : vid_priv->colour_bg;
121                         }
122                         break;
123                 }
124 #endif
125 #ifdef CONFIG_VIDEO_BPP32
126                 case VIDEO_BPP32: {
127                         uint32_t *dst = line;
128
129                         for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
130                                 *dst-- = (pfont[i] & mask) ? vid_priv->colour_fg
131                                         : vid_priv->colour_bg;
132                         }
133                         break;
134                 }
135 #endif
136                 default:
137                         return -ENOSYS;
138                 }
139                 line += vid_priv->line_length;
140                 mask >>= 1;
141         }
142
143         return VID_TO_POS(VIDEO_FONT_WIDTH);
144 }
145
146
147 static int console_set_row_2(struct udevice *dev, uint row, int clr)
148 {
149         struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
150         void *line;
151         int pixels = VIDEO_FONT_HEIGHT * vid_priv->xsize;
152         int i;
153
154         line = vid_priv->fb + vid_priv->ysize * vid_priv->line_length -
155                 (row + 1) * VIDEO_FONT_HEIGHT * vid_priv->line_length;
156         switch (vid_priv->bpix) {
157 #ifdef CONFIG_VIDEO_BPP8
158         case VIDEO_BPP8: {
159                 uint8_t *dst = line;
160
161                 for (i = 0; i < pixels; i++)
162                         *dst++ = clr;
163                 break;
164         }
165 #endif
166 #ifdef CONFIG_VIDEO_BPP16
167         case VIDEO_BPP16: {
168                 uint16_t *dst = line;
169
170                 for (i = 0; i < pixels; i++)
171                         *dst++ = clr;
172                 break;
173         }
174 #endif
175 #ifdef CONFIG_VIDEO_BPP32
176         case VIDEO_BPP32: {
177                 uint32_t *dst = line;
178
179                 for (i = 0; i < pixels; i++)
180                         *dst++ = clr;
181                 break;
182         }
183 #endif
184         default:
185                 return -ENOSYS;
186         }
187
188         return 0;
189 }
190
191 static int console_move_rows_2(struct udevice *dev, uint rowdst, uint rowsrc,
192                                uint count)
193 {
194         struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
195         void *dst;
196         void *src;
197         void *end;
198
199         end = vid_priv->fb + vid_priv->ysize * vid_priv->line_length;
200         dst = end - (rowdst + count) * VIDEO_FONT_HEIGHT *
201                 vid_priv->line_length;
202         src = end - (rowsrc + count) * VIDEO_FONT_HEIGHT *
203                 vid_priv->line_length;
204         memmove(dst, src, VIDEO_FONT_HEIGHT * vid_priv->line_length * count);
205
206         return 0;
207 }
208
209 static int console_putc_xy_2(struct udevice *dev, uint x_frac, uint y, char ch)
210 {
211         struct vidconsole_priv *vc_priv = dev_get_uclass_priv(dev);
212         struct udevice *vid = dev->parent;
213         struct video_priv *vid_priv = dev_get_uclass_priv(vid);
214         int i, row;
215         void *line;
216
217         if (x_frac + VID_TO_POS(vc_priv->x_charsize) > vc_priv->xsize_frac)
218                 return -EAGAIN;
219
220         line = vid_priv->fb + (vid_priv->ysize - y - 1) *
221                         vid_priv->line_length +
222                         (vid_priv->xsize - VID_TO_PIXEL(x_frac) -
223                         VIDEO_FONT_WIDTH - 1) * VNBYTES(vid_priv->bpix);
224
225         for (row = 0; row < VIDEO_FONT_HEIGHT; row++) {
226                 uchar bits = video_fontdata[ch * VIDEO_FONT_HEIGHT + row];
227
228                 switch (vid_priv->bpix) {
229 #ifdef CONFIG_VIDEO_BPP8
230                 case VIDEO_BPP8: {
231                         uint8_t *dst = line;
232
233                         for (i = 0; i < VIDEO_FONT_WIDTH; i++) {
234                                 *dst-- = (bits & 0x80) ? vid_priv->colour_fg
235                                         : vid_priv->colour_bg;
236                                 bits <<= 1;
237                         }
238                         break;
239                 }
240 #endif
241 #ifdef CONFIG_VIDEO_BPP16
242                 case VIDEO_BPP16: {
243                         uint16_t *dst = line;
244
245                         for (i = 0; i < VIDEO_FONT_WIDTH; i++) {
246                                 *dst-- = (bits & 0x80) ? vid_priv->colour_fg
247                                         : vid_priv->colour_bg;
248                                 bits <<= 1;
249                         }
250                         break;
251                 }
252 #endif
253 #ifdef CONFIG_VIDEO_BPP32
254                 case VIDEO_BPP32: {
255                         uint32_t *dst = line;
256
257                         for (i = 0; i < VIDEO_FONT_WIDTH; i++) {
258                                 *dst-- = (bits & 0x80) ? vid_priv->colour_fg
259                                         : vid_priv->colour_bg;
260                                 bits <<= 1;
261                         }
262                         break;
263                 }
264 #endif
265                 default:
266                         return -ENOSYS;
267                 }
268                 line -= vid_priv->line_length;
269         }
270
271         return VID_TO_POS(VIDEO_FONT_WIDTH);
272 }
273
274 static int console_set_row_3(struct udevice *dev, uint row, int clr)
275 {
276         struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
277         int pbytes = VNBYTES(vid_priv->bpix);
278         void *line;
279         int i, j;
280
281         line = vid_priv->fb + row * VIDEO_FONT_HEIGHT * pbytes;
282         for (j = 0; j < vid_priv->ysize; j++) {
283                 switch (vid_priv->bpix) {
284 #ifdef CONFIG_VIDEO_BPP8
285                 case VIDEO_BPP8: {
286                         uint8_t *dst = line;
287
288                         for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
289                                 *dst++ = clr;
290                         break;
291                 }
292 #endif
293 #ifdef CONFIG_VIDEO_BPP16
294                 case VIDEO_BPP16: {
295                         uint16_t *dst = line;
296
297                         for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
298                                 *dst++ = clr;
299                         break;
300                 }
301 #endif
302 #ifdef CONFIG_VIDEO_BPP32
303                 case VIDEO_BPP32: {
304                         uint32_t *dst = line;
305
306                         for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
307                                 *dst++ = clr;
308                         break;
309                 }
310 #endif
311                 default:
312                         return -ENOSYS;
313                 }
314                 line += vid_priv->line_length;
315         }
316
317         return 0;
318 }
319
320 static int console_move_rows_3(struct udevice *dev, uint rowdst, uint rowsrc,
321                                uint count)
322 {
323         struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
324         void *dst;
325         void *src;
326         int pbytes = VNBYTES(vid_priv->bpix);
327         int j;
328
329         dst = vid_priv->fb + rowdst * VIDEO_FONT_HEIGHT * pbytes;
330         src = vid_priv->fb + rowsrc * VIDEO_FONT_HEIGHT * pbytes;
331
332         for (j = 0; j < vid_priv->ysize; j++) {
333                 memmove(dst, src, VIDEO_FONT_HEIGHT * pbytes * count);
334                 src += vid_priv->line_length;
335                 dst += vid_priv->line_length;
336         }
337
338         return 0;
339 }
340
341 static int console_putc_xy_3(struct udevice *dev, uint x_frac, uint y, char ch)
342 {
343         struct vidconsole_priv *vc_priv = dev_get_uclass_priv(dev);
344         struct udevice *vid = dev->parent;
345         struct video_priv *vid_priv = dev_get_uclass_priv(vid);
346         int pbytes = VNBYTES(vid_priv->bpix);
347         int i, col;
348         int mask = 0x80;
349         void *line = vid_priv->fb +
350                 (vid_priv->ysize - VID_TO_PIXEL(x_frac) - 1) *
351                 vid_priv->line_length + y * pbytes;
352         uchar *pfont = video_fontdata + ch * VIDEO_FONT_HEIGHT;
353
354         if (x_frac + VID_TO_POS(vc_priv->x_charsize) > vc_priv->xsize_frac)
355                 return -EAGAIN;
356
357         for (col = 0; col < VIDEO_FONT_HEIGHT; col++) {
358                 switch (vid_priv->bpix) {
359 #ifdef CONFIG_VIDEO_BPP8
360                 case VIDEO_BPP8: {
361                         uint8_t *dst = line;
362
363                         for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
364                                 *dst++ = (pfont[i] & mask) ? vid_priv->colour_fg
365                                         : vid_priv->colour_bg;
366                         }
367                         break;
368                 }
369 #endif
370 #ifdef CONFIG_VIDEO_BPP16
371                 case VIDEO_BPP16: {
372                         uint16_t *dst = line;
373
374                         for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
375                                 *dst++ = (pfont[i] & mask) ? vid_priv->colour_fg
376                                         : vid_priv->colour_bg;
377                         }
378                         break;
379                 }
380 #endif
381 #ifdef CONFIG_VIDEO_BPP32
382                 case VIDEO_BPP32: {
383                         uint32_t *dst = line;
384
385                         for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
386                                 *dst++ = (pfont[i] & mask) ? vid_priv->colour_fg
387                                         : vid_priv->colour_bg;
388                         }
389                         break;
390                 }
391 #endif
392                 default:
393                         return -ENOSYS;
394                 }
395                 line -= vid_priv->line_length;
396                 mask >>= 1;
397         }
398
399         return VID_TO_POS(VIDEO_FONT_WIDTH);
400 }
401
402
403 static int console_probe_2(struct udevice *dev)
404 {
405         struct vidconsole_priv *vc_priv = dev_get_uclass_priv(dev);
406         struct udevice *vid_dev = dev->parent;
407         struct video_priv *vid_priv = dev_get_uclass_priv(vid_dev);
408
409         vc_priv->x_charsize = VIDEO_FONT_WIDTH;
410         vc_priv->y_charsize = VIDEO_FONT_HEIGHT;
411         vc_priv->cols = vid_priv->xsize / VIDEO_FONT_WIDTH;
412         vc_priv->rows = vid_priv->ysize / VIDEO_FONT_HEIGHT;
413
414         return 0;
415 }
416
417 static int console_probe_1_3(struct udevice *dev)
418 {
419         struct vidconsole_priv *vc_priv = dev_get_uclass_priv(dev);
420         struct udevice *vid_dev = dev->parent;
421         struct video_priv *vid_priv = dev_get_uclass_priv(vid_dev);
422
423         vc_priv->x_charsize = VIDEO_FONT_WIDTH;
424         vc_priv->y_charsize = VIDEO_FONT_HEIGHT;
425         vc_priv->cols = vid_priv->ysize / VIDEO_FONT_WIDTH;
426         vc_priv->rows = vid_priv->xsize / VIDEO_FONT_HEIGHT;
427         vc_priv->xsize_frac = VID_TO_POS(vid_priv->ysize);
428
429         return 0;
430 }
431
432 struct vidconsole_ops console_ops_1 = {
433         .putc_xy        = console_putc_xy_1,
434         .move_rows      = console_move_rows_1,
435         .set_row        = console_set_row_1,
436 };
437
438 struct vidconsole_ops console_ops_2 = {
439         .putc_xy        = console_putc_xy_2,
440         .move_rows      = console_move_rows_2,
441         .set_row        = console_set_row_2,
442 };
443
444 struct vidconsole_ops console_ops_3 = {
445         .putc_xy        = console_putc_xy_3,
446         .move_rows      = console_move_rows_3,
447         .set_row        = console_set_row_3,
448 };
449
450 U_BOOT_DRIVER(vidconsole_1) = {
451         .name   = "vidconsole1",
452         .id     = UCLASS_VIDEO_CONSOLE,
453         .ops    = &console_ops_1,
454         .probe  = console_probe_1_3,
455 };
456
457 U_BOOT_DRIVER(vidconsole_2) = {
458         .name   = "vidconsole2",
459         .id     = UCLASS_VIDEO_CONSOLE,
460         .ops    = &console_ops_2,
461         .probe  = console_probe_2,
462 };
463
464 U_BOOT_DRIVER(vidconsole_3) = {
465         .name   = "vidconsole3",
466         .id     = UCLASS_VIDEO_CONSOLE,
467         .ops    = &console_ops_3,
468         .probe  = console_probe_1_3,
469 };