projects/linux·blob master · refs

508 lines · 12.7 KiB

1// SPDX-License-Identifier: GPL-2.0
2
3#include <linux/fb.h>
4#include <linux/linux_logo.h>
5
6#include "fb_internal.h"
7
8bool fb_center_logo __read_mostly;
9int fb_logo_count __read_mostly = -1;
10
11static inline unsigned int safe_shift(unsigned int d, int n)
12{
13 return n < 0 ? d >> -n : d << n;
14}
15
16static void fb_set_logocmap(struct fb_info *info,
17 const struct linux_logo *logo)
18{
19 struct fb_cmap palette_cmap;
20 u16 palette_green[16];
21 u16 palette_blue[16];
22 u16 palette_red[16];
23 int i, j, n;
24 const unsigned char *clut = logo->clut;
25
26 palette_cmap.start = 0;
27 palette_cmap.len = 16;
28 palette_cmap.red = palette_red;
29 palette_cmap.green = palette_green;
30 palette_cmap.blue = palette_blue;
31 palette_cmap.transp = NULL;
32
33 for (i = 0; i < logo->clutsize; i += n) {
34 n = logo->clutsize - i;
35 /* palette_cmap provides space for only 16 colors at once */
36 if (n > 16)
37 n = 16;
38 palette_cmap.start = 32 + i;
39 palette_cmap.len = n;
40 for (j = 0; j < n; ++j) {
41 palette_cmap.red[j] = clut[0] << 8 | clut[0];
42 palette_cmap.green[j] = clut[1] << 8 | clut[1];
43 palette_cmap.blue[j] = clut[2] << 8 | clut[2];
44 clut += 3;
45 }
46 fb_set_cmap(&palette_cmap, info);
47 }
48}
49
50static void fb_set_logo_truepalette(struct fb_info *info,
51 const struct linux_logo *logo,
52 u32 *palette)
53{
54 static const unsigned char mask[] = {
55 0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff
56 };
57 unsigned char redmask, greenmask, bluemask;
58 int redshift, greenshift, blueshift;
59 int i;
60 const unsigned char *clut = logo->clut;
61
62 /*
63 * We have to create a temporary palette since console palette is only
64 * 16 colors long.
65 */
66 /* Bug: Doesn't obey msb_right ... (who needs that?) */
67 redmask = mask[info->var.red.length < 8 ? info->var.red.length : 8];
68 greenmask = mask[info->var.green.length < 8 ? info->var.green.length : 8];
69 bluemask = mask[info->var.blue.length < 8 ? info->var.blue.length : 8];
70 redshift = info->var.red.offset - (8 - info->var.red.length);
71 greenshift = info->var.green.offset - (8 - info->var.green.length);
72 blueshift = info->var.blue.offset - (8 - info->var.blue.length);
73
74 for (i = 0; i < logo->clutsize; i++) {
75 palette[i+32] = (safe_shift((clut[0] & redmask), redshift) |
76 safe_shift((clut[1] & greenmask), greenshift) |
77 safe_shift((clut[2] & bluemask), blueshift));
78 clut += 3;
79 }
80}
81
82static void fb_set_logo_directpalette(struct fb_info *info,
83 const struct linux_logo *logo,
84 u32 *palette)
85{
86 int redshift, greenshift, blueshift;
87 int i;
88
89 redshift = info->var.red.offset;
90 greenshift = info->var.green.offset;
91 blueshift = info->var.blue.offset;
92
93 for (i = 32; i < 32 + logo->clutsize; i++)
94 palette[i] = i << redshift | i << greenshift | i << blueshift;
95}
96
97static void fb_set_logo(struct fb_info *info,
98 const struct linux_logo *logo, u8 *dst,
99 int depth)
100{
101 int i, j, k;
102 const u8 *src = logo->data;
103 u8 xor = (info->fix.visual == FB_VISUAL_MONO01) ? 0xff : 0;
104 u8 fg = 1, d;
105
106 switch (fb_get_color_depth(&info->var, &info->fix)) {
107 case 1:
108 fg = 1;
109 break;
110 case 2:
111 fg = 3;
112 break;
113 default:
114 fg = 7;
115 break;
116 }
117
118 if (info->fix.visual == FB_VISUAL_MONO01 ||
119 info->fix.visual == FB_VISUAL_MONO10)
120 fg = ~((u8) (0xfff << info->var.green.length));
121
122 switch (depth) {
123 case 4:
124 for (i = 0; i < logo->height; i++)
125 for (j = 0; j < logo->width; src++) {
126 *dst++ = *src >> 4;
127 j++;
128 if (j < logo->width) {
129 *dst++ = *src & 0x0f;
130 j++;
131 }
132 }
133 break;
134 case 1:
135 for (i = 0; i < logo->height; i++) {
136 for (j = 0; j < logo->width; src++) {
137 d = *src ^ xor;
138 for (k = 7; k >= 0 && j < logo->width; k--) {
139 *dst++ = ((d >> k) & 1) ? fg : 0;
140 j++;
141 }
142 }
143 }
144 break;
145 }
146}
147
148/*
149 * Three (3) kinds of logo maps exist. linux_logo_clut224 (>16 colors),
150 * linux_logo_vga16 (16 colors) and linux_logo_mono (2 colors). Depending on
151 * the visual format and color depth of the framebuffer, the DAC, the
152 * pseudo_palette, and the logo data will be adjusted accordingly.
153 *
154 * Case 1 - linux_logo_clut224:
155 * Color exceeds the number of console colors (16), thus we set the hardware DAC
156 * using fb_set_cmap() appropriately. The "needs_cmapreset" flag will be set.
157 *
158 * For visuals that require color info from the pseudo_palette, we also construct
159 * one for temporary use. The "needs_directpalette" or "needs_truepalette" flags
160 * will be set.
161 *
162 * Case 2 - linux_logo_vga16:
163 * The number of colors just matches the console colors, thus there is no need
164 * to set the DAC or the pseudo_palette. However, the bitmap is packed, ie,
165 * each byte contains color information for two pixels (upper and lower nibble).
166 * To be consistent with fb_imageblit() usage, we therefore separate the two
167 * nibbles into separate bytes. The "depth" flag will be set to 4.
168 *
169 * Case 3 - linux_logo_mono:
170 * This is similar with Case 2. Each byte contains information for 8 pixels.
171 * We isolate each bit and expand each into a byte. The "depth" flag will
172 * be set to 1.
173 */
174static struct logo_data {
175 int depth;
176 int needs_directpalette;
177 int needs_truepalette;
178 int needs_cmapreset;
179 const struct linux_logo *logo;
180} fb_logo __read_mostly;
181
182static void fb_rotate_logo_ud(const u8 *in, u8 *out, u32 width, u32 height)
183{
184 u32 size = width * height, i;
185
186 out += size - 1;
187
188 for (i = size; i--; )
189 *out-- = *in++;
190}
191
192static void fb_rotate_logo_cw(const u8 *in, u8 *out, u32 width, u32 height)
193{
194 int i, j, h = height - 1;
195
196 for (i = 0; i < height; i++)
197 for (j = 0; j < width; j++)
198 out[height * j + h - i] = *in++;
199}
200
201static void fb_rotate_logo_ccw(const u8 *in, u8 *out, u32 width, u32 height)
202{
203 int i, j, w = width - 1;
204
205 for (i = 0; i < height; i++)
206 for (j = 0; j < width; j++)
207 out[height * (w - j) + i] = *in++;
208}
209
210static void fb_rotate_logo(struct fb_info *info, u8 *dst,
211 struct fb_image *image, int rotate)
212{
213 u32 tmp;
214
215 if (rotate == FB_ROTATE_UD) {
216 fb_rotate_logo_ud(image->data, dst, image->width,
217 image->height);
218 image->dx = info->var.xres - image->width - image->dx;
219 image->dy = info->var.yres - image->height - image->dy;
220 } else if (rotate == FB_ROTATE_CW) {
221 fb_rotate_logo_cw(image->data, dst, image->width,
222 image->height);
223 swap(image->width, image->height);
224 tmp = image->dy;
225 image->dy = image->dx;
226 image->dx = info->var.xres - image->width - tmp;
227 } else if (rotate == FB_ROTATE_CCW) {
228 fb_rotate_logo_ccw(image->data, dst, image->width,
229 image->height);
230 swap(image->width, image->height);
231 tmp = image->dx;
232 image->dx = image->dy;
233 image->dy = info->var.yres - image->height - tmp;
234 }
235
236 image->data = dst;
237}
238
239static void fb_do_show_logo(struct fb_info *info, struct fb_image *image,
240 int rotate, unsigned int num)
241{
242 unsigned int x;
243
244 if (image->width > info->var.xres || image->height > info->var.yres)
245 return;
246
247 if (rotate == FB_ROTATE_UR) {
248 for (x = 0;
249 x < num && image->dx + image->width <= info->var.xres;
250 x++) {
251 info->fbops->fb_imageblit(info, image);
252 image->dx += image->width + 8;
253 }
254 } else if (rotate == FB_ROTATE_UD) {
255 u32 dx = image->dx;
256
257 for (x = 0; x < num && image->dx <= dx; x++) {
258 info->fbops->fb_imageblit(info, image);
259 image->dx -= image->width + 8;
260 }
261 } else if (rotate == FB_ROTATE_CW) {
262 for (x = 0;
263 x < num && image->dy + image->height <= info->var.yres;
264 x++) {
265 info->fbops->fb_imageblit(info, image);
266 image->dy += image->height + 8;
267 }
268 } else if (rotate == FB_ROTATE_CCW) {
269 u32 dy = image->dy;
270
271 for (x = 0; x < num && image->dy <= dy; x++) {
272 info->fbops->fb_imageblit(info, image);
273 image->dy -= image->height + 8;
274 }
275 }
276}
277
278static int fb_show_logo_line(struct fb_info *info, int rotate,
279 const struct linux_logo *logo, int y,
280 unsigned int n)
281{
282 u32 *palette = NULL, *saved_pseudo_palette = NULL;
283 unsigned char *logo_new = NULL, *logo_rotate = NULL;
284 struct fb_image image;
285
286 /* Return if the frame buffer is not mapped or suspended */
287 if (logo == NULL || info->state != FBINFO_STATE_RUNNING ||
288 info->fbops->owner)
289 return 0;
290
291 image.depth = 8;
292 image.data = logo->data;
293
294 if (fb_logo.needs_cmapreset)
295 fb_set_logocmap(info, logo);
296
297 if (fb_logo.needs_truepalette ||
298 fb_logo.needs_directpalette) {
299 palette = kmalloc(256 * 4, GFP_KERNEL);
300 if (palette == NULL)
301 return 0;
302
303 if (fb_logo.needs_truepalette)
304 fb_set_logo_truepalette(info, logo, palette);
305 else
306 fb_set_logo_directpalette(info, logo, palette);
307
308 saved_pseudo_palette = info->pseudo_palette;
309 info->pseudo_palette = palette;
310 }
311
312 if (fb_logo.depth <= 4) {
313 logo_new = kmalloc_array(logo->width, logo->height,
314 GFP_KERNEL);
315 if (logo_new == NULL) {
316 kfree(palette);
317 if (saved_pseudo_palette)
318 info->pseudo_palette = saved_pseudo_palette;
319 return 0;
320 }
321 image.data = logo_new;
322 fb_set_logo(info, logo, logo_new, fb_logo.depth);
323 }
324
325 if (fb_center_logo) {
326 int xres = info->var.xres;
327 int yres = info->var.yres;
328
329 if (rotate == FB_ROTATE_CW || rotate == FB_ROTATE_CCW) {
330 xres = info->var.yres;
331 yres = info->var.xres;
332 }
333
334 while (n && (n * (logo->width + 8) - 8 > xres))
335 --n;
336 image.dx = (xres - (n * (logo->width + 8) - 8)) / 2;
337 image.dy = y ?: (yres - logo->height) / 2;
338 } else {
339 image.dx = 0;
340 image.dy = y;
341 }
342
343 image.width = logo->width;
344 image.height = logo->height;
345
346 if (rotate) {
347 logo_rotate = kmalloc_array(logo->width, logo->height,
348 GFP_KERNEL);
349 if (logo_rotate)
350 fb_rotate_logo(info, logo_rotate, &image, rotate);
351 }
352
353 fb_do_show_logo(info, &image, rotate, n);
354
355 kfree(palette);
356 if (saved_pseudo_palette != NULL)
357 info->pseudo_palette = saved_pseudo_palette;
358 kfree(logo_new);
359 kfree(logo_rotate);
360 return image.dy + logo->height;
361}
362
363#ifdef CONFIG_FB_LOGO_EXTRA
364
365#define FB_LOGO_EX_NUM_MAX 10
366static struct logo_data_extra {
367 const struct linux_logo *logo;
368 unsigned int n;
369} fb_logo_ex[FB_LOGO_EX_NUM_MAX];
370static unsigned int fb_logo_ex_num;
371
372void fb_append_extra_logo(const struct linux_logo *logo, unsigned int n)
373{
374 if (!n || fb_logo_ex_num == FB_LOGO_EX_NUM_MAX)
375 return;
376
377 fb_logo_ex[fb_logo_ex_num].logo = logo;
378 fb_logo_ex[fb_logo_ex_num].n = n;
379 fb_logo_ex_num++;
380}
381
382static int fb_prepare_extra_logos(struct fb_info *info, unsigned int height,
383 unsigned int yres)
384{
385 unsigned int i;
386
387 /* FIXME: logo_ex supports only truecolor fb. */
388 if (info->fix.visual != FB_VISUAL_TRUECOLOR)
389 fb_logo_ex_num = 0;
390
391 for (i = 0; i < fb_logo_ex_num; i++) {
392 if (fb_logo_ex[i].logo->type != fb_logo.logo->type) {
393 fb_logo_ex[i].logo = NULL;
394 continue;
395 }
396 height += fb_logo_ex[i].logo->height;
397 if (height > yres) {
398 height -= fb_logo_ex[i].logo->height;
399 fb_logo_ex_num = i;
400 break;
401 }
402 }
403 return height;
404}
405
406static int fb_show_extra_logos(struct fb_info *info, int y, int rotate)
407{
408 unsigned int i;
409
410 for (i = 0; i < fb_logo_ex_num; i++)
411 y = fb_show_logo_line(info, rotate,
412 fb_logo_ex[i].logo, y, fb_logo_ex[i].n);
413
414 return y;
415}
416#endif /* CONFIG_FB_LOGO_EXTRA */
417
418int fb_prepare_logo(struct fb_info *info, int rotate)
419{
420 int depth = fb_get_color_depth(&info->var, &info->fix);
421 unsigned int yres;
422 int height;
423
424 memset(&fb_logo, 0, sizeof(struct logo_data));
425
426 if (info->flags & FBINFO_MISC_TILEBLITTING ||
427 info->fbops->owner || !fb_logo_count)
428 return 0;
429
430 if (info->fix.visual == FB_VISUAL_DIRECTCOLOR) {
431 depth = info->var.blue.length;
432 if (info->var.red.length < depth)
433 depth = info->var.red.length;
434 if (info->var.green.length < depth)
435 depth = info->var.green.length;
436 }
437
438 if (info->fix.visual == FB_VISUAL_STATIC_PSEUDOCOLOR && depth > 4) {
439 /* assume console colormap */
440 depth = 4;
441 }
442
443 /* Return if no suitable logo was found */
444 fb_logo.logo = fb_find_logo(depth);
445
446 if (!fb_logo.logo)
447 return 0;
448
449 if (rotate == FB_ROTATE_UR || rotate == FB_ROTATE_UD)
450 yres = info->var.yres;
451 else
452 yres = info->var.xres;
453
454 if (fb_logo.logo->height > yres) {
455 fb_logo.logo = NULL;
456 return 0;
457 }
458
459 /* What depth we asked for might be different from what we get */
460 if (fb_logo.logo->type == LINUX_LOGO_CLUT224)
461 fb_logo.depth = 8;
462 else if (fb_logo.logo->type == LINUX_LOGO_VGA16)
463 fb_logo.depth = 4;
464 else
465 fb_logo.depth = 1;
466
467
468 if (fb_logo.depth > 4 && depth > 4) {
469 switch (info->fix.visual) {
470 case FB_VISUAL_TRUECOLOR:
471 fb_logo.needs_truepalette = 1;
472 break;
473 case FB_VISUAL_DIRECTCOLOR:
474 fb_logo.needs_directpalette = 1;
475 fb_logo.needs_cmapreset = 1;
476 break;
477 case FB_VISUAL_PSEUDOCOLOR:
478 fb_logo.needs_cmapreset = 1;
479 break;
480 }
481 }
482
483 height = fb_logo.logo->height;
484 if (fb_center_logo)
485 height += (yres - fb_logo.logo->height) / 2;
486#ifdef CONFIG_FB_LOGO_EXTRA
487 height = fb_prepare_extra_logos(info, height, yres);
488#endif
489
490 return height;
491}
492
493int fb_show_logo(struct fb_info *info, int rotate)
494{
495 unsigned int count;
496 int y;
497
498 if (!fb_logo_count)
499 return 0;
500
501 count = fb_logo_count < 0 ? num_online_cpus() : fb_logo_count;
502 y = fb_show_logo_line(info, rotate, fb_logo.logo, 0, count);
503#ifdef CONFIG_FB_LOGO_EXTRA
504 y = fb_show_extra_logos(info, y, rotate);
505#endif
506
507 return y;
508}