1 /*
2  *  linux/drivers/video/fbmem.c
3  *
4  *  Copyright (C) 1994 Martin Schaller
5  *
6  *	2001 - Documented with DocBook
7  *	- Brad Douglas <brad@neruo.com>
8  *
9  * This file is subject to the terms and conditions of the GNU General Public
10  * License.  See the file COPYING in the main directory of this archive
11  * for more details.
12  */
13 
14 #include <linux/module.h>
15 
16 #include <linux/aperture.h>
17 #include <linux/compat.h>
18 #include <linux/types.h>
19 #include <linux/errno.h>
20 #include <linux/kernel.h>
21 #include <linux/major.h>
22 #include <linux/slab.h>
23 #include <linux/mm.h>
24 #include <linux/mman.h>
25 #include <linux/vt.h>
26 #include <linux/init.h>
27 #include <linux/linux_logo.h>
28 #include <linux/proc_fs.h>
29 #include <linux/platform_device.h>
30 #include <linux/seq_file.h>
31 #include <linux/console.h>
32 #include <linux/kmod.h>
33 #include <linux/err.h>
34 #include <linux/device.h>
35 #include <linux/efi.h>
36 #include <linux/fb.h>
37 #include <linux/fbcon.h>
38 #include <linux/mem_encrypt.h>
39 #include <linux/pci.h>
40 
41 #include <asm/fb.h>
42 
43 #include <video/vga.h>
44 
45     /*
46      *  Frame buffer device initialization and setup routines
47      */
48 
49 #define FBPIXMAPSIZE	(1024 * 8)
50 
51 static DEFINE_MUTEX(registration_lock);
52 
53 struct fb_info *registered_fb[FB_MAX] __read_mostly;
54 int num_registered_fb __read_mostly;
55 #define for_each_registered_fb(i)		\
56 	for (i = 0; i < FB_MAX; i++)		\
57 		if (!registered_fb[i]) {} else
58 
59 bool fb_center_logo __read_mostly;
60 
61 int fb_logo_count __read_mostly = -1;
62 
get_fb_info(unsigned int idx)63 static struct fb_info *get_fb_info(unsigned int idx)
64 {
65 	struct fb_info *fb_info;
66 
67 	if (idx >= FB_MAX)
68 		return ERR_PTR(-ENODEV);
69 
70 	mutex_lock(&registration_lock);
71 	fb_info = registered_fb[idx];
72 	if (fb_info)
73 		refcount_inc(&fb_info->count);
74 	mutex_unlock(&registration_lock);
75 
76 	return fb_info;
77 }
78 
put_fb_info(struct fb_info * fb_info)79 static void put_fb_info(struct fb_info *fb_info)
80 {
81 	if (!refcount_dec_and_test(&fb_info->count))
82 		return;
83 	if (fb_info->fbops->fb_destroy)
84 		fb_info->fbops->fb_destroy(fb_info);
85 }
86 
87 /*
88  * Helpers
89  */
90 
fb_get_color_depth(struct fb_var_screeninfo * var,struct fb_fix_screeninfo * fix)91 int fb_get_color_depth(struct fb_var_screeninfo *var,
92 		       struct fb_fix_screeninfo *fix)
93 {
94 	int depth = 0;
95 
96 	if (fix->visual == FB_VISUAL_MONO01 ||
97 	    fix->visual == FB_VISUAL_MONO10)
98 		depth = 1;
99 	else {
100 		if (var->green.length == var->blue.length &&
101 		    var->green.length == var->red.length &&
102 		    var->green.offset == var->blue.offset &&
103 		    var->green.offset == var->red.offset)
104 			depth = var->green.length;
105 		else
106 			depth = var->green.length + var->red.length +
107 				var->blue.length;
108 	}
109 
110 	return depth;
111 }
112 EXPORT_SYMBOL(fb_get_color_depth);
113 
114 /*
115  * Data padding functions.
116  */
fb_pad_aligned_buffer(u8 * dst,u32 d_pitch,u8 * src,u32 s_pitch,u32 height)117 void fb_pad_aligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 s_pitch, u32 height)
118 {
119 	__fb_pad_aligned_buffer(dst, d_pitch, src, s_pitch, height);
120 }
121 EXPORT_SYMBOL(fb_pad_aligned_buffer);
122 
fb_pad_unaligned_buffer(u8 * dst,u32 d_pitch,u8 * src,u32 idx,u32 height,u32 shift_high,u32 shift_low,u32 mod)123 void fb_pad_unaligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 idx, u32 height,
124 				u32 shift_high, u32 shift_low, u32 mod)
125 {
126 	u8 mask = (u8) (0xfff << shift_high), tmp;
127 	int i, j;
128 
129 	for (i = height; i--; ) {
130 		for (j = 0; j < idx; j++) {
131 			tmp = dst[j];
132 			tmp &= mask;
133 			tmp |= *src >> shift_low;
134 			dst[j] = tmp;
135 			tmp = *src << shift_high;
136 			dst[j+1] = tmp;
137 			src++;
138 		}
139 		tmp = dst[idx];
140 		tmp &= mask;
141 		tmp |= *src >> shift_low;
142 		dst[idx] = tmp;
143 		if (shift_high < mod) {
144 			tmp = *src << shift_high;
145 			dst[idx+1] = tmp;
146 		}
147 		src++;
148 		dst += d_pitch;
149 	}
150 }
151 EXPORT_SYMBOL(fb_pad_unaligned_buffer);
152 
153 /*
154  * we need to lock this section since fb_cursor
155  * may use fb_imageblit()
156  */
fb_get_buffer_offset(struct fb_info * info,struct fb_pixmap * buf,u32 size)157 char* fb_get_buffer_offset(struct fb_info *info, struct fb_pixmap *buf, u32 size)
158 {
159 	u32 align = buf->buf_align - 1, offset;
160 	char *addr = buf->addr;
161 
162 	/* If IO mapped, we need to sync before access, no sharing of
163 	 * the pixmap is done
164 	 */
165 	if (buf->flags & FB_PIXMAP_IO) {
166 		if (info->fbops->fb_sync && (buf->flags & FB_PIXMAP_SYNC))
167 			info->fbops->fb_sync(info);
168 		return addr;
169 	}
170 
171 	/* See if we fit in the remaining pixmap space */
172 	offset = buf->offset + align;
173 	offset &= ~align;
174 	if (offset + size > buf->size) {
175 		/* We do not fit. In order to be able to re-use the buffer,
176 		 * we must ensure no asynchronous DMA'ing or whatever operation
177 		 * is in progress, we sync for that.
178 		 */
179 		if (info->fbops->fb_sync && (buf->flags & FB_PIXMAP_SYNC))
180 			info->fbops->fb_sync(info);
181 		offset = 0;
182 	}
183 	buf->offset = offset + size;
184 	addr += offset;
185 
186 	return addr;
187 }
188 EXPORT_SYMBOL(fb_get_buffer_offset);
189 
190 #ifdef CONFIG_LOGO
191 
safe_shift(unsigned d,int n)192 static inline unsigned safe_shift(unsigned d, int n)
193 {
194 	return n < 0 ? d >> -n : d << n;
195 }
196 
fb_set_logocmap(struct fb_info * info,const struct linux_logo * logo)197 static void fb_set_logocmap(struct fb_info *info,
198 				   const struct linux_logo *logo)
199 {
200 	struct fb_cmap palette_cmap;
201 	u16 palette_green[16];
202 	u16 palette_blue[16];
203 	u16 palette_red[16];
204 	int i, j, n;
205 	const unsigned char *clut = logo->clut;
206 
207 	palette_cmap.start = 0;
208 	palette_cmap.len = 16;
209 	palette_cmap.red = palette_red;
210 	palette_cmap.green = palette_green;
211 	palette_cmap.blue = palette_blue;
212 	palette_cmap.transp = NULL;
213 
214 	for (i = 0; i < logo->clutsize; i += n) {
215 		n = logo->clutsize - i;
216 		/* palette_cmap provides space for only 16 colors at once */
217 		if (n > 16)
218 			n = 16;
219 		palette_cmap.start = 32 + i;
220 		palette_cmap.len = n;
221 		for (j = 0; j < n; ++j) {
222 			palette_cmap.red[j] = clut[0] << 8 | clut[0];
223 			palette_cmap.green[j] = clut[1] << 8 | clut[1];
224 			palette_cmap.blue[j] = clut[2] << 8 | clut[2];
225 			clut += 3;
226 		}
227 		fb_set_cmap(&palette_cmap, info);
228 	}
229 }
230 
fb_set_logo_truepalette(struct fb_info * info,const struct linux_logo * logo,u32 * palette)231 static void  fb_set_logo_truepalette(struct fb_info *info,
232 					    const struct linux_logo *logo,
233 					    u32 *palette)
234 {
235 	static const unsigned char mask[] = { 0,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff };
236 	unsigned char redmask, greenmask, bluemask;
237 	int redshift, greenshift, blueshift;
238 	int i;
239 	const unsigned char *clut = logo->clut;
240 
241 	/*
242 	 * We have to create a temporary palette since console palette is only
243 	 * 16 colors long.
244 	 */
245 	/* Bug: Doesn't obey msb_right ... (who needs that?) */
246 	redmask   = mask[info->var.red.length   < 8 ? info->var.red.length   : 8];
247 	greenmask = mask[info->var.green.length < 8 ? info->var.green.length : 8];
248 	bluemask  = mask[info->var.blue.length  < 8 ? info->var.blue.length  : 8];
249 	redshift   = info->var.red.offset   - (8 - info->var.red.length);
250 	greenshift = info->var.green.offset - (8 - info->var.green.length);
251 	blueshift  = info->var.blue.offset  - (8 - info->var.blue.length);
252 
253 	for ( i = 0; i < logo->clutsize; i++) {
254 		palette[i+32] = (safe_shift((clut[0] & redmask), redshift) |
255 				 safe_shift((clut[1] & greenmask), greenshift) |
256 				 safe_shift((clut[2] & bluemask), blueshift));
257 		clut += 3;
258 	}
259 }
260 
fb_set_logo_directpalette(struct fb_info * info,const struct linux_logo * logo,u32 * palette)261 static void fb_set_logo_directpalette(struct fb_info *info,
262 					     const struct linux_logo *logo,
263 					     u32 *palette)
264 {
265 	int redshift, greenshift, blueshift;
266 	int i;
267 
268 	redshift = info->var.red.offset;
269 	greenshift = info->var.green.offset;
270 	blueshift = info->var.blue.offset;
271 
272 	for (i = 32; i < 32 + logo->clutsize; i++)
273 		palette[i] = i << redshift | i << greenshift | i << blueshift;
274 }
275 
fb_set_logo(struct fb_info * info,const struct linux_logo * logo,u8 * dst,int depth)276 static void fb_set_logo(struct fb_info *info,
277 			       const struct linux_logo *logo, u8 *dst,
278 			       int depth)
279 {
280 	int i, j, k;
281 	const u8 *src = logo->data;
282 	u8 xor = (info->fix.visual == FB_VISUAL_MONO01) ? 0xff : 0;
283 	u8 fg = 1, d;
284 
285 	switch (fb_get_color_depth(&info->var, &info->fix)) {
286 	case 1:
287 		fg = 1;
288 		break;
289 	case 2:
290 		fg = 3;
291 		break;
292 	default:
293 		fg = 7;
294 		break;
295 	}
296 
297 	if (info->fix.visual == FB_VISUAL_MONO01 ||
298 	    info->fix.visual == FB_VISUAL_MONO10)
299 		fg = ~((u8) (0xfff << info->var.green.length));
300 
301 	switch (depth) {
302 	case 4:
303 		for (i = 0; i < logo->height; i++)
304 			for (j = 0; j < logo->width; src++) {
305 				*dst++ = *src >> 4;
306 				j++;
307 				if (j < logo->width) {
308 					*dst++ = *src & 0x0f;
309 					j++;
310 				}
311 			}
312 		break;
313 	case 1:
314 		for (i = 0; i < logo->height; i++) {
315 			for (j = 0; j < logo->width; src++) {
316 				d = *src ^ xor;
317 				for (k = 7; k >= 0 && j < logo->width; k--) {
318 					*dst++ = ((d >> k) & 1) ? fg : 0;
319 					j++;
320 				}
321 			}
322 		}
323 		break;
324 	}
325 }
326 
327 /*
328  * Three (3) kinds of logo maps exist.  linux_logo_clut224 (>16 colors),
329  * linux_logo_vga16 (16 colors) and linux_logo_mono (2 colors).  Depending on
330  * the visual format and color depth of the framebuffer, the DAC, the
331  * pseudo_palette, and the logo data will be adjusted accordingly.
332  *
333  * Case 1 - linux_logo_clut224:
334  * Color exceeds the number of console colors (16), thus we set the hardware DAC
335  * using fb_set_cmap() appropriately.  The "needs_cmapreset"  flag will be set.
336  *
337  * For visuals that require color info from the pseudo_palette, we also construct
338  * one for temporary use. The "needs_directpalette" or "needs_truepalette" flags
339  * will be set.
340  *
341  * Case 2 - linux_logo_vga16:
342  * The number of colors just matches the console colors, thus there is no need
343  * to set the DAC or the pseudo_palette.  However, the bitmap is packed, ie,
344  * each byte contains color information for two pixels (upper and lower nibble).
345  * To be consistent with fb_imageblit() usage, we therefore separate the two
346  * nibbles into separate bytes. The "depth" flag will be set to 4.
347  *
348  * Case 3 - linux_logo_mono:
349  * This is similar with Case 2.  Each byte contains information for 8 pixels.
350  * We isolate each bit and expand each into a byte. The "depth" flag will
351  * be set to 1.
352  */
353 static struct logo_data {
354 	int depth;
355 	int needs_directpalette;
356 	int needs_truepalette;
357 	int needs_cmapreset;
358 	const struct linux_logo *logo;
359 } fb_logo __read_mostly;
360 
fb_rotate_logo_ud(const u8 * in,u8 * out,u32 width,u32 height)361 static void fb_rotate_logo_ud(const u8 *in, u8 *out, u32 width, u32 height)
362 {
363 	u32 size = width * height, i;
364 
365 	out += size - 1;
366 
367 	for (i = size; i--; )
368 		*out-- = *in++;
369 }
370 
fb_rotate_logo_cw(const u8 * in,u8 * out,u32 width,u32 height)371 static void fb_rotate_logo_cw(const u8 *in, u8 *out, u32 width, u32 height)
372 {
373 	int i, j, h = height - 1;
374 
375 	for (i = 0; i < height; i++)
376 		for (j = 0; j < width; j++)
377 				out[height * j + h - i] = *in++;
378 }
379 
fb_rotate_logo_ccw(const u8 * in,u8 * out,u32 width,u32 height)380 static void fb_rotate_logo_ccw(const u8 *in, u8 *out, u32 width, u32 height)
381 {
382 	int i, j, w = width - 1;
383 
384 	for (i = 0; i < height; i++)
385 		for (j = 0; j < width; j++)
386 			out[height * (w - j) + i] = *in++;
387 }
388 
fb_rotate_logo(struct fb_info * info,u8 * dst,struct fb_image * image,int rotate)389 static void fb_rotate_logo(struct fb_info *info, u8 *dst,
390 			   struct fb_image *image, int rotate)
391 {
392 	u32 tmp;
393 
394 	if (rotate == FB_ROTATE_UD) {
395 		fb_rotate_logo_ud(image->data, dst, image->width,
396 				  image->height);
397 		image->dx = info->var.xres - image->width - image->dx;
398 		image->dy = info->var.yres - image->height - image->dy;
399 	} else if (rotate == FB_ROTATE_CW) {
400 		fb_rotate_logo_cw(image->data, dst, image->width,
401 				  image->height);
402 		swap(image->width, image->height);
403 		tmp = image->dy;
404 		image->dy = image->dx;
405 		image->dx = info->var.xres - image->width - tmp;
406 	} else if (rotate == FB_ROTATE_CCW) {
407 		fb_rotate_logo_ccw(image->data, dst, image->width,
408 				   image->height);
409 		swap(image->width, image->height);
410 		tmp = image->dx;
411 		image->dx = image->dy;
412 		image->dy = info->var.yres - image->height - tmp;
413 	}
414 
415 	image->data = dst;
416 }
417 
fb_do_show_logo(struct fb_info * info,struct fb_image * image,int rotate,unsigned int num)418 static void fb_do_show_logo(struct fb_info *info, struct fb_image *image,
419 			    int rotate, unsigned int num)
420 {
421 	unsigned int x;
422 
423 	if (image->width > info->var.xres || image->height > info->var.yres)
424 		return;
425 
426 	if (rotate == FB_ROTATE_UR) {
427 		for (x = 0;
428 		     x < num && image->dx + image->width <= info->var.xres;
429 		     x++) {
430 			info->fbops->fb_imageblit(info, image);
431 			image->dx += image->width + 8;
432 		}
433 	} else if (rotate == FB_ROTATE_UD) {
434 		u32 dx = image->dx;
435 
436 		for (x = 0; x < num && image->dx <= dx; x++) {
437 			info->fbops->fb_imageblit(info, image);
438 			image->dx -= image->width + 8;
439 		}
440 	} else if (rotate == FB_ROTATE_CW) {
441 		for (x = 0;
442 		     x < num && image->dy + image->height <= info->var.yres;
443 		     x++) {
444 			info->fbops->fb_imageblit(info, image);
445 			image->dy += image->height + 8;
446 		}
447 	} else if (rotate == FB_ROTATE_CCW) {
448 		u32 dy = image->dy;
449 
450 		for (x = 0; x < num && image->dy <= dy; x++) {
451 			info->fbops->fb_imageblit(info, image);
452 			image->dy -= image->height + 8;
453 		}
454 	}
455 }
456 
fb_show_logo_line(struct fb_info * info,int rotate,const struct linux_logo * logo,int y,unsigned int n)457 static int fb_show_logo_line(struct fb_info *info, int rotate,
458 			     const struct linux_logo *logo, int y,
459 			     unsigned int n)
460 {
461 	u32 *palette = NULL, *saved_pseudo_palette = NULL;
462 	unsigned char *logo_new = NULL, *logo_rotate = NULL;
463 	struct fb_image image;
464 
465 	/* Return if the frame buffer is not mapped or suspended */
466 	if (logo == NULL || info->state != FBINFO_STATE_RUNNING ||
467 	    info->fbops->owner)
468 		return 0;
469 
470 	image.depth = 8;
471 	image.data = logo->data;
472 
473 	if (fb_logo.needs_cmapreset)
474 		fb_set_logocmap(info, logo);
475 
476 	if (fb_logo.needs_truepalette ||
477 	    fb_logo.needs_directpalette) {
478 		palette = kmalloc(256 * 4, GFP_KERNEL);
479 		if (palette == NULL)
480 			return 0;
481 
482 		if (fb_logo.needs_truepalette)
483 			fb_set_logo_truepalette(info, logo, palette);
484 		else
485 			fb_set_logo_directpalette(info, logo, palette);
486 
487 		saved_pseudo_palette = info->pseudo_palette;
488 		info->pseudo_palette = palette;
489 	}
490 
491 	if (fb_logo.depth <= 4) {
492 		logo_new = kmalloc_array(logo->width, logo->height,
493 					 GFP_KERNEL);
494 		if (logo_new == NULL) {
495 			kfree(palette);
496 			if (saved_pseudo_palette)
497 				info->pseudo_palette = saved_pseudo_palette;
498 			return 0;
499 		}
500 		image.data = logo_new;
501 		fb_set_logo(info, logo, logo_new, fb_logo.depth);
502 	}
503 
504 	if (fb_center_logo) {
505 		int xres = info->var.xres;
506 		int yres = info->var.yres;
507 
508 		if (rotate == FB_ROTATE_CW || rotate == FB_ROTATE_CCW) {
509 			xres = info->var.yres;
510 			yres = info->var.xres;
511 		}
512 
513 		while (n && (n * (logo->width + 8) - 8 > xres))
514 			--n;
515 		image.dx = (xres - (n * (logo->width + 8) - 8)) / 2;
516 		image.dy = y ?: (yres - logo->height) / 2;
517 	} else {
518 		image.dx = 0;
519 		image.dy = y;
520 	}
521 
522 	image.width = logo->width;
523 	image.height = logo->height;
524 
525 	if (rotate) {
526 		logo_rotate = kmalloc_array(logo->width, logo->height,
527 					    GFP_KERNEL);
528 		if (logo_rotate)
529 			fb_rotate_logo(info, logo_rotate, &image, rotate);
530 	}
531 
532 	fb_do_show_logo(info, &image, rotate, n);
533 
534 	kfree(palette);
535 	if (saved_pseudo_palette != NULL)
536 		info->pseudo_palette = saved_pseudo_palette;
537 	kfree(logo_new);
538 	kfree(logo_rotate);
539 	return image.dy + logo->height;
540 }
541 
542 
543 #ifdef CONFIG_FB_LOGO_EXTRA
544 
545 #define FB_LOGO_EX_NUM_MAX 10
546 static struct logo_data_extra {
547 	const struct linux_logo *logo;
548 	unsigned int n;
549 } fb_logo_ex[FB_LOGO_EX_NUM_MAX];
550 static unsigned int fb_logo_ex_num;
551 
fb_append_extra_logo(const struct linux_logo * logo,unsigned int n)552 void fb_append_extra_logo(const struct linux_logo *logo, unsigned int n)
553 {
554 	if (!n || fb_logo_ex_num == FB_LOGO_EX_NUM_MAX)
555 		return;
556 
557 	fb_logo_ex[fb_logo_ex_num].logo = logo;
558 	fb_logo_ex[fb_logo_ex_num].n = n;
559 	fb_logo_ex_num++;
560 }
561 
fb_prepare_extra_logos(struct fb_info * info,unsigned int height,unsigned int yres)562 static int fb_prepare_extra_logos(struct fb_info *info, unsigned int height,
563 				  unsigned int yres)
564 {
565 	unsigned int i;
566 
567 	/* FIXME: logo_ex supports only truecolor fb. */
568 	if (info->fix.visual != FB_VISUAL_TRUECOLOR)
569 		fb_logo_ex_num = 0;
570 
571 	for (i = 0; i < fb_logo_ex_num; i++) {
572 		if (fb_logo_ex[i].logo->type != fb_logo.logo->type) {
573 			fb_logo_ex[i].logo = NULL;
574 			continue;
575 		}
576 		height += fb_logo_ex[i].logo->height;
577 		if (height > yres) {
578 			height -= fb_logo_ex[i].logo->height;
579 			fb_logo_ex_num = i;
580 			break;
581 		}
582 	}
583 	return height;
584 }
585 
fb_show_extra_logos(struct fb_info * info,int y,int rotate)586 static int fb_show_extra_logos(struct fb_info *info, int y, int rotate)
587 {
588 	unsigned int i;
589 
590 	for (i = 0; i < fb_logo_ex_num; i++)
591 		y = fb_show_logo_line(info, rotate,
592 				      fb_logo_ex[i].logo, y, fb_logo_ex[i].n);
593 
594 	return y;
595 }
596 
597 #else /* !CONFIG_FB_LOGO_EXTRA */
598 
fb_prepare_extra_logos(struct fb_info * info,unsigned int height,unsigned int yres)599 static inline int fb_prepare_extra_logos(struct fb_info *info,
600 					 unsigned int height,
601 					 unsigned int yres)
602 {
603 	return height;
604 }
605 
fb_show_extra_logos(struct fb_info * info,int y,int rotate)606 static inline int fb_show_extra_logos(struct fb_info *info, int y, int rotate)
607 {
608 	return y;
609 }
610 
611 #endif /* CONFIG_FB_LOGO_EXTRA */
612 
613 
fb_prepare_logo(struct fb_info * info,int rotate)614 int fb_prepare_logo(struct fb_info *info, int rotate)
615 {
616 	int depth = fb_get_color_depth(&info->var, &info->fix);
617 	unsigned int yres;
618 	int height;
619 
620 	memset(&fb_logo, 0, sizeof(struct logo_data));
621 
622 	if (info->flags & FBINFO_MISC_TILEBLITTING ||
623 	    info->fbops->owner || !fb_logo_count)
624 		return 0;
625 
626 	if (info->fix.visual == FB_VISUAL_DIRECTCOLOR) {
627 		depth = info->var.blue.length;
628 		if (info->var.red.length < depth)
629 			depth = info->var.red.length;
630 		if (info->var.green.length < depth)
631 			depth = info->var.green.length;
632 	}
633 
634 	if (info->fix.visual == FB_VISUAL_STATIC_PSEUDOCOLOR && depth > 4) {
635 		/* assume console colormap */
636 		depth = 4;
637 	}
638 
639 	/* Return if no suitable logo was found */
640 	fb_logo.logo = fb_find_logo(depth);
641 
642 	if (!fb_logo.logo) {
643 		return 0;
644 	}
645 
646 	if (rotate == FB_ROTATE_UR || rotate == FB_ROTATE_UD)
647 		yres = info->var.yres;
648 	else
649 		yres = info->var.xres;
650 
651 	if (fb_logo.logo->height > yres) {
652 		fb_logo.logo = NULL;
653 		return 0;
654 	}
655 
656 	/* What depth we asked for might be different from what we get */
657 	if (fb_logo.logo->type == LINUX_LOGO_CLUT224)
658 		fb_logo.depth = 8;
659 	else if (fb_logo.logo->type == LINUX_LOGO_VGA16)
660 		fb_logo.depth = 4;
661 	else
662 		fb_logo.depth = 1;
663 
664 
665 	if (fb_logo.depth > 4 && depth > 4) {
666 		switch (info->fix.visual) {
667 		case FB_VISUAL_TRUECOLOR:
668 			fb_logo.needs_truepalette = 1;
669 			break;
670 		case FB_VISUAL_DIRECTCOLOR:
671 			fb_logo.needs_directpalette = 1;
672 			fb_logo.needs_cmapreset = 1;
673 			break;
674 		case FB_VISUAL_PSEUDOCOLOR:
675 			fb_logo.needs_cmapreset = 1;
676 			break;
677 		}
678 	}
679 
680 	height = fb_logo.logo->height;
681 	if (fb_center_logo)
682 		height += (yres - fb_logo.logo->height) / 2;
683 
684 	return fb_prepare_extra_logos(info, height, yres);
685 }
686 
fb_show_logo(struct fb_info * info,int rotate)687 int fb_show_logo(struct fb_info *info, int rotate)
688 {
689 	unsigned int count;
690 	int y;
691 
692 	if (!fb_logo_count)
693 		return 0;
694 
695 	count = fb_logo_count < 0 ? num_online_cpus() : fb_logo_count;
696 	y = fb_show_logo_line(info, rotate, fb_logo.logo, 0, count);
697 	y = fb_show_extra_logos(info, y, rotate);
698 
699 	return y;
700 }
701 #else
fb_prepare_logo(struct fb_info * info,int rotate)702 int fb_prepare_logo(struct fb_info *info, int rotate) { return 0; }
fb_show_logo(struct fb_info * info,int rotate)703 int fb_show_logo(struct fb_info *info, int rotate) { return 0; }
704 #endif /* CONFIG_LOGO */
705 EXPORT_SYMBOL(fb_prepare_logo);
706 EXPORT_SYMBOL(fb_show_logo);
707 
fb_seq_start(struct seq_file * m,loff_t * pos)708 static void *fb_seq_start(struct seq_file *m, loff_t *pos)
709 {
710 	mutex_lock(&registration_lock);
711 	return (*pos < FB_MAX) ? pos : NULL;
712 }
713 
fb_seq_next(struct seq_file * m,void * v,loff_t * pos)714 static void *fb_seq_next(struct seq_file *m, void *v, loff_t *pos)
715 {
716 	(*pos)++;
717 	return (*pos < FB_MAX) ? pos : NULL;
718 }
719 
fb_seq_stop(struct seq_file * m,void * v)720 static void fb_seq_stop(struct seq_file *m, void *v)
721 {
722 	mutex_unlock(&registration_lock);
723 }
724 
fb_seq_show(struct seq_file * m,void * v)725 static int fb_seq_show(struct seq_file *m, void *v)
726 {
727 	int i = *(loff_t *)v;
728 	struct fb_info *fi = registered_fb[i];
729 
730 	if (fi)
731 		seq_printf(m, "%d %s\n", fi->node, fi->fix.id);
732 	return 0;
733 }
734 
735 static const struct seq_operations __maybe_unused proc_fb_seq_ops = {
736 	.start	= fb_seq_start,
737 	.next	= fb_seq_next,
738 	.stop	= fb_seq_stop,
739 	.show	= fb_seq_show,
740 };
741 
742 /*
743  * We hold a reference to the fb_info in file->private_data,
744  * but if the current registered fb has changed, we don't
745  * actually want to use it.
746  *
747  * So look up the fb_info using the inode minor number,
748  * and just verify it against the reference we have.
749  */
file_fb_info(struct file * file)750 static struct fb_info *file_fb_info(struct file *file)
751 {
752 	struct inode *inode = file_inode(file);
753 	int fbidx = iminor(inode);
754 	struct fb_info *info = registered_fb[fbidx];
755 
756 	if (info != file->private_data)
757 		info = NULL;
758 	return info;
759 }
760 
761 static ssize_t
fb_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)762 fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
763 {
764 	unsigned long p = *ppos;
765 	struct fb_info *info = file_fb_info(file);
766 	u8 *buffer, *dst;
767 	u8 __iomem *src;
768 	int c, cnt = 0, err = 0;
769 	unsigned long total_size;
770 
771 	if (!info || ! info->screen_base)
772 		return -ENODEV;
773 
774 	if (info->state != FBINFO_STATE_RUNNING)
775 		return -EPERM;
776 
777 	if (info->fbops->fb_read)
778 		return info->fbops->fb_read(info, buf, count, ppos);
779 
780 	total_size = info->screen_size;
781 
782 	if (total_size == 0)
783 		total_size = info->fix.smem_len;
784 
785 	if (p >= total_size)
786 		return 0;
787 
788 	if (count >= total_size)
789 		count = total_size;
790 
791 	if (count + p > total_size)
792 		count = total_size - p;
793 
794 	buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,
795 			 GFP_KERNEL);
796 	if (!buffer)
797 		return -ENOMEM;
798 
799 	src = (u8 __iomem *) (info->screen_base + p);
800 
801 	if (info->fbops->fb_sync)
802 		info->fbops->fb_sync(info);
803 
804 	while (count) {
805 		c  = (count > PAGE_SIZE) ? PAGE_SIZE : count;
806 		dst = buffer;
807 		fb_memcpy_fromfb(dst, src, c);
808 		dst += c;
809 		src += c;
810 
811 		if (copy_to_user(buf, buffer, c)) {
812 			err = -EFAULT;
813 			break;
814 		}
815 		*ppos += c;
816 		buf += c;
817 		cnt += c;
818 		count -= c;
819 	}
820 
821 	kfree(buffer);
822 
823 	return (err) ? err : cnt;
824 }
825 
826 static ssize_t
fb_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)827 fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
828 {
829 	unsigned long p = *ppos;
830 	struct fb_info *info = file_fb_info(file);
831 	u8 *buffer, *src;
832 	u8 __iomem *dst;
833 	int c, cnt = 0, err = 0;
834 	unsigned long total_size;
835 
836 	if (!info || !info->screen_base)
837 		return -ENODEV;
838 
839 	if (info->state != FBINFO_STATE_RUNNING)
840 		return -EPERM;
841 
842 	if (info->fbops->fb_write)
843 		return info->fbops->fb_write(info, buf, count, ppos);
844 
845 	total_size = info->screen_size;
846 
847 	if (total_size == 0)
848 		total_size = info->fix.smem_len;
849 
850 	if (p > total_size)
851 		return -EFBIG;
852 
853 	if (count > total_size) {
854 		err = -EFBIG;
855 		count = total_size;
856 	}
857 
858 	if (count + p > total_size) {
859 		if (!err)
860 			err = -ENOSPC;
861 
862 		count = total_size - p;
863 	}
864 
865 	buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,
866 			 GFP_KERNEL);
867 	if (!buffer)
868 		return -ENOMEM;
869 
870 	dst = (u8 __iomem *) (info->screen_base + p);
871 
872 	if (info->fbops->fb_sync)
873 		info->fbops->fb_sync(info);
874 
875 	while (count) {
876 		c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
877 		src = buffer;
878 
879 		if (copy_from_user(src, buf, c)) {
880 			err = -EFAULT;
881 			break;
882 		}
883 
884 		fb_memcpy_tofb(dst, src, c);
885 		dst += c;
886 		src += c;
887 		*ppos += c;
888 		buf += c;
889 		cnt += c;
890 		count -= c;
891 	}
892 
893 	kfree(buffer);
894 
895 	return (cnt) ? cnt : err;
896 }
897 
898 int
fb_pan_display(struct fb_info * info,struct fb_var_screeninfo * var)899 fb_pan_display(struct fb_info *info, struct fb_var_screeninfo *var)
900 {
901 	struct fb_fix_screeninfo *fix = &info->fix;
902 	unsigned int yres = info->var.yres;
903 	int err = 0;
904 
905 	if (var->yoffset > 0) {
906 		if (var->vmode & FB_VMODE_YWRAP) {
907 			if (!fix->ywrapstep || (var->yoffset % fix->ywrapstep))
908 				err = -EINVAL;
909 			else
910 				yres = 0;
911 		} else if (!fix->ypanstep || (var->yoffset % fix->ypanstep))
912 			err = -EINVAL;
913 	}
914 
915 	if (var->xoffset > 0 && (!fix->xpanstep ||
916 				 (var->xoffset % fix->xpanstep)))
917 		err = -EINVAL;
918 
919 	if (err || !info->fbops->fb_pan_display ||
920 	    var->yoffset > info->var.yres_virtual - yres ||
921 	    var->xoffset > info->var.xres_virtual - info->var.xres)
922 		return -EINVAL;
923 
924 	if ((err = info->fbops->fb_pan_display(var, info)))
925 		return err;
926 	info->var.xoffset = var->xoffset;
927 	info->var.yoffset = var->yoffset;
928 	if (var->vmode & FB_VMODE_YWRAP)
929 		info->var.vmode |= FB_VMODE_YWRAP;
930 	else
931 		info->var.vmode &= ~FB_VMODE_YWRAP;
932 	return 0;
933 }
934 EXPORT_SYMBOL(fb_pan_display);
935 
fb_check_caps(struct fb_info * info,struct fb_var_screeninfo * var,u32 activate)936 static int fb_check_caps(struct fb_info *info, struct fb_var_screeninfo *var,
937 			 u32 activate)
938 {
939 	struct fb_blit_caps caps, fbcaps;
940 	int err = 0;
941 
942 	memset(&caps, 0, sizeof(caps));
943 	memset(&fbcaps, 0, sizeof(fbcaps));
944 	caps.flags = (activate & FB_ACTIVATE_ALL) ? 1 : 0;
945 	fbcon_get_requirement(info, &caps);
946 	info->fbops->fb_get_caps(info, &fbcaps, var);
947 
948 	if (((fbcaps.x ^ caps.x) & caps.x) ||
949 	    ((fbcaps.y ^ caps.y) & caps.y) ||
950 	    (fbcaps.len < caps.len))
951 		err = -EINVAL;
952 
953 	return err;
954 }
955 
956 int
fb_set_var(struct fb_info * info,struct fb_var_screeninfo * var)957 fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var)
958 {
959 	int ret = 0;
960 	u32 activate;
961 	struct fb_var_screeninfo old_var;
962 	struct fb_videomode mode;
963 	struct fb_event event;
964 	u32 unused;
965 
966 	if (var->activate & FB_ACTIVATE_INV_MODE) {
967 		struct fb_videomode mode1, mode2;
968 
969 		fb_var_to_videomode(&mode1, var);
970 		fb_var_to_videomode(&mode2, &info->var);
971 		/* make sure we don't delete the videomode of current var */
972 		ret = fb_mode_is_equal(&mode1, &mode2);
973 		if (!ret) {
974 			ret = fbcon_mode_deleted(info, &mode1);
975 			if (!ret)
976 				fb_delete_videomode(&mode1, &info->modelist);
977 		}
978 
979 		return ret ? -EINVAL : 0;
980 	}
981 
982 	if (!(var->activate & FB_ACTIVATE_FORCE) &&
983 	    !memcmp(&info->var, var, sizeof(struct fb_var_screeninfo)))
984 		return 0;
985 
986 	activate = var->activate;
987 
988 	/* When using FOURCC mode, make sure the red, green, blue and
989 	 * transp fields are set to 0.
990 	 */
991 	if ((info->fix.capabilities & FB_CAP_FOURCC) &&
992 	    var->grayscale > 1) {
993 		if (var->red.offset     || var->green.offset    ||
994 		    var->blue.offset    || var->transp.offset   ||
995 		    var->red.length     || var->green.length    ||
996 		    var->blue.length    || var->transp.length   ||
997 		    var->red.msb_right  || var->green.msb_right ||
998 		    var->blue.msb_right || var->transp.msb_right)
999 			return -EINVAL;
1000 	}
1001 
1002 	if (!info->fbops->fb_check_var) {
1003 		*var = info->var;
1004 		return 0;
1005 	}
1006 
1007 	/* bitfill_aligned() assumes that it's at least 8x8 */
1008 	if (var->xres < 8 || var->yres < 8)
1009 		return -EINVAL;
1010 
1011 	/* Too huge resolution causes multiplication overflow. */
1012 	if (check_mul_overflow(var->xres, var->yres, &unused) ||
1013 	    check_mul_overflow(var->xres_virtual, var->yres_virtual, &unused))
1014 		return -EINVAL;
1015 
1016 	ret = info->fbops->fb_check_var(var, info);
1017 
1018 	if (ret)
1019 		return ret;
1020 
1021 	/* verify that virtual resolution >= physical resolution */
1022 	if (var->xres_virtual < var->xres ||
1023 	    var->yres_virtual < var->yres) {
1024 		pr_warn("WARNING: fbcon: Driver '%s' missed to adjust virtual screen size (%ux%u vs. %ux%u)\n",
1025 			info->fix.id,
1026 			var->xres_virtual, var->yres_virtual,
1027 			var->xres, var->yres);
1028 		return -EINVAL;
1029 	}
1030 
1031 	if ((var->activate & FB_ACTIVATE_MASK) != FB_ACTIVATE_NOW)
1032 		return 0;
1033 
1034 	if (info->fbops->fb_get_caps) {
1035 		ret = fb_check_caps(info, var, activate);
1036 
1037 		if (ret)
1038 			return ret;
1039 	}
1040 
1041 	old_var = info->var;
1042 	info->var = *var;
1043 
1044 	if (info->fbops->fb_set_par) {
1045 		ret = info->fbops->fb_set_par(info);
1046 
1047 		if (ret) {
1048 			info->var = old_var;
1049 			printk(KERN_WARNING "detected "
1050 				"fb_set_par error, "
1051 				"error code: %d\n", ret);
1052 			return ret;
1053 		}
1054 	}
1055 
1056 	fb_pan_display(info, &info->var);
1057 	fb_set_cmap(&info->cmap, info);
1058 	fb_var_to_videomode(&mode, &info->var);
1059 
1060 	if (info->modelist.prev && info->modelist.next &&
1061 	    !list_empty(&info->modelist))
1062 		ret = fb_add_videomode(&mode, &info->modelist);
1063 
1064 	if (ret)
1065 		return ret;
1066 
1067 	event.info = info;
1068 	event.data = &mode;
1069 	fb_notifier_call_chain(FB_EVENT_MODE_CHANGE, &event);
1070 
1071 	return 0;
1072 }
1073 EXPORT_SYMBOL(fb_set_var);
1074 
1075 int
fb_blank(struct fb_info * info,int blank)1076 fb_blank(struct fb_info *info, int blank)
1077 {
1078 	struct fb_event event;
1079 	int ret = -EINVAL;
1080 
1081 	if (blank > FB_BLANK_POWERDOWN)
1082 		blank = FB_BLANK_POWERDOWN;
1083 
1084 	event.info = info;
1085 	event.data = &blank;
1086 
1087 	if (info->fbops->fb_blank)
1088 		ret = info->fbops->fb_blank(blank, info);
1089 
1090 	if (!ret)
1091 		fb_notifier_call_chain(FB_EVENT_BLANK, &event);
1092 
1093 	return ret;
1094 }
1095 EXPORT_SYMBOL(fb_blank);
1096 
do_fb_ioctl(struct fb_info * info,unsigned int cmd,unsigned long arg)1097 static long do_fb_ioctl(struct fb_info *info, unsigned int cmd,
1098 			unsigned long arg)
1099 {
1100 	const struct fb_ops *fb;
1101 	struct fb_var_screeninfo var;
1102 	struct fb_fix_screeninfo fix;
1103 	struct fb_cmap cmap_from;
1104 	struct fb_cmap_user cmap;
1105 	void __user *argp = (void __user *)arg;
1106 	long ret = 0;
1107 
1108 	switch (cmd) {
1109 	case FBIOGET_VSCREENINFO:
1110 		lock_fb_info(info);
1111 		var = info->var;
1112 		unlock_fb_info(info);
1113 
1114 		ret = copy_to_user(argp, &var, sizeof(var)) ? -EFAULT : 0;
1115 		break;
1116 	case FBIOPUT_VSCREENINFO:
1117 		if (copy_from_user(&var, argp, sizeof(var)))
1118 			return -EFAULT;
1119 		console_lock();
1120 		lock_fb_info(info);
1121 		ret = fbcon_modechange_possible(info, &var);
1122 		if (!ret)
1123 			ret = fb_set_var(info, &var);
1124 		if (!ret)
1125 			fbcon_update_vcs(info, var.activate & FB_ACTIVATE_ALL);
1126 		unlock_fb_info(info);
1127 		console_unlock();
1128 		if (!ret && copy_to_user(argp, &var, sizeof(var)))
1129 			ret = -EFAULT;
1130 		break;
1131 	case FBIOGET_FSCREENINFO:
1132 		lock_fb_info(info);
1133 		memcpy(&fix, &info->fix, sizeof(fix));
1134 		if (info->flags & FBINFO_HIDE_SMEM_START)
1135 			fix.smem_start = 0;
1136 		unlock_fb_info(info);
1137 
1138 		ret = copy_to_user(argp, &fix, sizeof(fix)) ? -EFAULT : 0;
1139 		break;
1140 	case FBIOPUTCMAP:
1141 		if (copy_from_user(&cmap, argp, sizeof(cmap)))
1142 			return -EFAULT;
1143 		ret = fb_set_user_cmap(&cmap, info);
1144 		break;
1145 	case FBIOGETCMAP:
1146 		if (copy_from_user(&cmap, argp, sizeof(cmap)))
1147 			return -EFAULT;
1148 		lock_fb_info(info);
1149 		cmap_from = info->cmap;
1150 		unlock_fb_info(info);
1151 		ret = fb_cmap_to_user(&cmap_from, &cmap);
1152 		break;
1153 	case FBIOPAN_DISPLAY:
1154 		if (copy_from_user(&var, argp, sizeof(var)))
1155 			return -EFAULT;
1156 		console_lock();
1157 		lock_fb_info(info);
1158 		ret = fb_pan_display(info, &var);
1159 		unlock_fb_info(info);
1160 		console_unlock();
1161 		if (ret == 0 && copy_to_user(argp, &var, sizeof(var)))
1162 			return -EFAULT;
1163 		break;
1164 	case FBIO_CURSOR:
1165 		ret = -EINVAL;
1166 		break;
1167 	case FBIOGET_CON2FBMAP:
1168 		ret = fbcon_get_con2fb_map_ioctl(argp);
1169 		break;
1170 	case FBIOPUT_CON2FBMAP:
1171 		ret = fbcon_set_con2fb_map_ioctl(argp);
1172 		break;
1173 	case FBIOBLANK:
1174 		if (arg > FB_BLANK_POWERDOWN)
1175 			return -EINVAL;
1176 		console_lock();
1177 		lock_fb_info(info);
1178 		ret = fb_blank(info, arg);
1179 		/* might again call into fb_blank */
1180 		fbcon_fb_blanked(info, arg);
1181 		unlock_fb_info(info);
1182 		console_unlock();
1183 		break;
1184 	default:
1185 		lock_fb_info(info);
1186 		fb = info->fbops;
1187 		if (fb->fb_ioctl)
1188 			ret = fb->fb_ioctl(info, cmd, arg);
1189 		else
1190 			ret = -ENOTTY;
1191 		unlock_fb_info(info);
1192 	}
1193 	return ret;
1194 }
1195 
fb_ioctl(struct file * file,unsigned int cmd,unsigned long arg)1196 static long fb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1197 {
1198 	struct fb_info *info = file_fb_info(file);
1199 
1200 	if (!info)
1201 		return -ENODEV;
1202 	return do_fb_ioctl(info, cmd, arg);
1203 }
1204 
1205 #ifdef CONFIG_COMPAT
1206 struct fb_fix_screeninfo32 {
1207 	char			id[16];
1208 	compat_caddr_t		smem_start;
1209 	u32			smem_len;
1210 	u32			type;
1211 	u32			type_aux;
1212 	u32			visual;
1213 	u16			xpanstep;
1214 	u16			ypanstep;
1215 	u16			ywrapstep;
1216 	u32			line_length;
1217 	compat_caddr_t		mmio_start;
1218 	u32			mmio_len;
1219 	u32			accel;
1220 	u16			reserved[3];
1221 };
1222 
1223 struct fb_cmap32 {
1224 	u32			start;
1225 	u32			len;
1226 	compat_caddr_t	red;
1227 	compat_caddr_t	green;
1228 	compat_caddr_t	blue;
1229 	compat_caddr_t	transp;
1230 };
1231 
fb_getput_cmap(struct fb_info * info,unsigned int cmd,unsigned long arg)1232 static int fb_getput_cmap(struct fb_info *info, unsigned int cmd,
1233 			  unsigned long arg)
1234 {
1235 	struct fb_cmap32 cmap32;
1236 	struct fb_cmap cmap_from;
1237 	struct fb_cmap_user cmap;
1238 
1239 	if (copy_from_user(&cmap32, compat_ptr(arg), sizeof(cmap32)))
1240 		return -EFAULT;
1241 
1242 	cmap = (struct fb_cmap_user) {
1243 		.start	= cmap32.start,
1244 		.len	= cmap32.len,
1245 		.red	= compat_ptr(cmap32.red),
1246 		.green	= compat_ptr(cmap32.green),
1247 		.blue	= compat_ptr(cmap32.blue),
1248 		.transp	= compat_ptr(cmap32.transp),
1249 	};
1250 
1251 	if (cmd == FBIOPUTCMAP)
1252 		return fb_set_user_cmap(&cmap, info);
1253 
1254 	lock_fb_info(info);
1255 	cmap_from = info->cmap;
1256 	unlock_fb_info(info);
1257 
1258 	return fb_cmap_to_user(&cmap_from, &cmap);
1259 }
1260 
do_fscreeninfo_to_user(struct fb_fix_screeninfo * fix,struct fb_fix_screeninfo32 __user * fix32)1261 static int do_fscreeninfo_to_user(struct fb_fix_screeninfo *fix,
1262 				  struct fb_fix_screeninfo32 __user *fix32)
1263 {
1264 	__u32 data;
1265 	int err;
1266 
1267 	err = copy_to_user(&fix32->id, &fix->id, sizeof(fix32->id));
1268 
1269 	data = (__u32) (unsigned long) fix->smem_start;
1270 	err |= put_user(data, &fix32->smem_start);
1271 
1272 	err |= put_user(fix->smem_len, &fix32->smem_len);
1273 	err |= put_user(fix->type, &fix32->type);
1274 	err |= put_user(fix->type_aux, &fix32->type_aux);
1275 	err |= put_user(fix->visual, &fix32->visual);
1276 	err |= put_user(fix->xpanstep, &fix32->xpanstep);
1277 	err |= put_user(fix->ypanstep, &fix32->ypanstep);
1278 	err |= put_user(fix->ywrapstep, &fix32->ywrapstep);
1279 	err |= put_user(fix->line_length, &fix32->line_length);
1280 
1281 	data = (__u32) (unsigned long) fix->mmio_start;
1282 	err |= put_user(data, &fix32->mmio_start);
1283 
1284 	err |= put_user(fix->mmio_len, &fix32->mmio_len);
1285 	err |= put_user(fix->accel, &fix32->accel);
1286 	err |= copy_to_user(fix32->reserved, fix->reserved,
1287 			    sizeof(fix->reserved));
1288 
1289 	if (err)
1290 		return -EFAULT;
1291 	return 0;
1292 }
1293 
fb_get_fscreeninfo(struct fb_info * info,unsigned int cmd,unsigned long arg)1294 static int fb_get_fscreeninfo(struct fb_info *info, unsigned int cmd,
1295 			      unsigned long arg)
1296 {
1297 	struct fb_fix_screeninfo fix;
1298 
1299 	lock_fb_info(info);
1300 	fix = info->fix;
1301 	if (info->flags & FBINFO_HIDE_SMEM_START)
1302 		fix.smem_start = 0;
1303 	unlock_fb_info(info);
1304 	return do_fscreeninfo_to_user(&fix, compat_ptr(arg));
1305 }
1306 
fb_compat_ioctl(struct file * file,unsigned int cmd,unsigned long arg)1307 static long fb_compat_ioctl(struct file *file, unsigned int cmd,
1308 			    unsigned long arg)
1309 {
1310 	struct fb_info *info = file_fb_info(file);
1311 	const struct fb_ops *fb;
1312 	long ret = -ENOIOCTLCMD;
1313 
1314 	if (!info)
1315 		return -ENODEV;
1316 	fb = info->fbops;
1317 	switch(cmd) {
1318 	case FBIOGET_VSCREENINFO:
1319 	case FBIOPUT_VSCREENINFO:
1320 	case FBIOPAN_DISPLAY:
1321 	case FBIOGET_CON2FBMAP:
1322 	case FBIOPUT_CON2FBMAP:
1323 		arg = (unsigned long) compat_ptr(arg);
1324 		fallthrough;
1325 	case FBIOBLANK:
1326 		ret = do_fb_ioctl(info, cmd, arg);
1327 		break;
1328 
1329 	case FBIOGET_FSCREENINFO:
1330 		ret = fb_get_fscreeninfo(info, cmd, arg);
1331 		break;
1332 
1333 	case FBIOGETCMAP:
1334 	case FBIOPUTCMAP:
1335 		ret = fb_getput_cmap(info, cmd, arg);
1336 		break;
1337 
1338 	default:
1339 		if (fb->fb_compat_ioctl)
1340 			ret = fb->fb_compat_ioctl(info, cmd, arg);
1341 		break;
1342 	}
1343 	return ret;
1344 }
1345 #endif
1346 
1347 static int
fb_mmap(struct file * file,struct vm_area_struct * vma)1348 fb_mmap(struct file *file, struct vm_area_struct * vma)
1349 {
1350 	struct fb_info *info = file_fb_info(file);
1351 	unsigned long mmio_pgoff;
1352 	unsigned long start;
1353 	u32 len;
1354 
1355 	if (!info)
1356 		return -ENODEV;
1357 	mutex_lock(&info->mm_lock);
1358 
1359 	if (info->fbops->fb_mmap) {
1360 		int res;
1361 
1362 		/*
1363 		 * The framebuffer needs to be accessed decrypted, be sure
1364 		 * SME protection is removed ahead of the call
1365 		 */
1366 		vma->vm_page_prot = pgprot_decrypted(vma->vm_page_prot);
1367 		res = info->fbops->fb_mmap(info, vma);
1368 		mutex_unlock(&info->mm_lock);
1369 		return res;
1370 #if IS_ENABLED(CONFIG_FB_DEFERRED_IO)
1371 	} else if (info->fbdefio) {
1372 		/*
1373 		 * FB deferred I/O wants you to handle mmap in your drivers. At a
1374 		 * minimum, point struct fb_ops.fb_mmap to fb_deferred_io_mmap().
1375 		 */
1376 		dev_warn_once(info->dev, "fbdev mmap not set up for deferred I/O.\n");
1377 		mutex_unlock(&info->mm_lock);
1378 		return -ENODEV;
1379 #endif
1380 	}
1381 
1382 	/*
1383 	 * Ugh. This can be either the frame buffer mapping, or
1384 	 * if pgoff points past it, the mmio mapping.
1385 	 */
1386 	start = info->fix.smem_start;
1387 	len = info->fix.smem_len;
1388 	mmio_pgoff = PAGE_ALIGN((start & ~PAGE_MASK) + len) >> PAGE_SHIFT;
1389 	if (vma->vm_pgoff >= mmio_pgoff) {
1390 		if (info->var.accel_flags) {
1391 			mutex_unlock(&info->mm_lock);
1392 			return -EINVAL;
1393 		}
1394 
1395 		vma->vm_pgoff -= mmio_pgoff;
1396 		start = info->fix.mmio_start;
1397 		len = info->fix.mmio_len;
1398 	}
1399 	mutex_unlock(&info->mm_lock);
1400 
1401 	vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
1402 	fb_pgprotect(file, vma, start);
1403 
1404 	return vm_iomap_memory(vma, start, len);
1405 }
1406 
1407 static int
fb_open(struct inode * inode,struct file * file)1408 fb_open(struct inode *inode, struct file *file)
1409 __acquires(&info->lock)
1410 __releases(&info->lock)
1411 {
1412 	int fbidx = iminor(inode);
1413 	struct fb_info *info;
1414 	int res = 0;
1415 
1416 	info = get_fb_info(fbidx);
1417 	if (!info) {
1418 		request_module("fb%d", fbidx);
1419 		info = get_fb_info(fbidx);
1420 		if (!info)
1421 			return -ENODEV;
1422 	}
1423 	if (IS_ERR(info))
1424 		return PTR_ERR(info);
1425 
1426 	lock_fb_info(info);
1427 	if (!try_module_get(info->fbops->owner)) {
1428 		res = -ENODEV;
1429 		goto out;
1430 	}
1431 	file->private_data = info;
1432 	if (info->fbops->fb_open) {
1433 		res = info->fbops->fb_open(info,1);
1434 		if (res)
1435 			module_put(info->fbops->owner);
1436 	}
1437 #ifdef CONFIG_FB_DEFERRED_IO
1438 	if (info->fbdefio)
1439 		fb_deferred_io_open(info, inode, file);
1440 #endif
1441 out:
1442 	unlock_fb_info(info);
1443 	if (res)
1444 		put_fb_info(info);
1445 	return res;
1446 }
1447 
1448 static int
fb_release(struct inode * inode,struct file * file)1449 fb_release(struct inode *inode, struct file *file)
1450 __acquires(&info->lock)
1451 __releases(&info->lock)
1452 {
1453 	struct fb_info * const info = file->private_data;
1454 
1455 	lock_fb_info(info);
1456 	if (info->fbops->fb_release)
1457 		info->fbops->fb_release(info,1);
1458 	module_put(info->fbops->owner);
1459 	unlock_fb_info(info);
1460 	put_fb_info(info);
1461 	return 0;
1462 }
1463 
1464 #if defined(CONFIG_FB_PROVIDE_GET_FB_UNMAPPED_AREA) && !defined(CONFIG_MMU)
get_fb_unmapped_area(struct file * filp,unsigned long addr,unsigned long len,unsigned long pgoff,unsigned long flags)1465 unsigned long get_fb_unmapped_area(struct file *filp,
1466 				   unsigned long addr, unsigned long len,
1467 				   unsigned long pgoff, unsigned long flags)
1468 {
1469 	struct fb_info * const info = filp->private_data;
1470 	unsigned long fb_size = PAGE_ALIGN(info->fix.smem_len);
1471 
1472 	if (pgoff > fb_size || len > fb_size - pgoff)
1473 		return -EINVAL;
1474 
1475 	return (unsigned long)info->screen_base + pgoff;
1476 }
1477 #endif
1478 
1479 static const struct file_operations fb_fops = {
1480 	.owner =	THIS_MODULE,
1481 	.read =		fb_read,
1482 	.write =	fb_write,
1483 	.unlocked_ioctl = fb_ioctl,
1484 #ifdef CONFIG_COMPAT
1485 	.compat_ioctl = fb_compat_ioctl,
1486 #endif
1487 	.mmap =		fb_mmap,
1488 	.open =		fb_open,
1489 	.release =	fb_release,
1490 #if defined(HAVE_ARCH_FB_UNMAPPED_AREA) || \
1491 	(defined(CONFIG_FB_PROVIDE_GET_FB_UNMAPPED_AREA) && \
1492 	 !defined(CONFIG_MMU))
1493 	.get_unmapped_area = get_fb_unmapped_area,
1494 #endif
1495 #ifdef CONFIG_FB_DEFERRED_IO
1496 	.fsync =	fb_deferred_io_fsync,
1497 #endif
1498 	.llseek =	default_llseek,
1499 };
1500 
1501 struct class *fb_class;
1502 EXPORT_SYMBOL(fb_class);
1503 
fb_check_foreignness(struct fb_info * fi)1504 static int fb_check_foreignness(struct fb_info *fi)
1505 {
1506 	const bool foreign_endian = fi->flags & FBINFO_FOREIGN_ENDIAN;
1507 
1508 	fi->flags &= ~FBINFO_FOREIGN_ENDIAN;
1509 
1510 #ifdef __BIG_ENDIAN
1511 	fi->flags |= foreign_endian ? 0 : FBINFO_BE_MATH;
1512 #else
1513 	fi->flags |= foreign_endian ? FBINFO_BE_MATH : 0;
1514 #endif /* __BIG_ENDIAN */
1515 
1516 	if (fi->flags & FBINFO_BE_MATH && !fb_be_math(fi)) {
1517 		pr_err("%s: enable CONFIG_FB_BIG_ENDIAN to "
1518 		       "support this framebuffer\n", fi->fix.id);
1519 		return -ENOSYS;
1520 	} else if (!(fi->flags & FBINFO_BE_MATH) && fb_be_math(fi)) {
1521 		pr_err("%s: enable CONFIG_FB_LITTLE_ENDIAN to "
1522 		       "support this framebuffer\n", fi->fix.id);
1523 		return -ENOSYS;
1524 	}
1525 
1526 	return 0;
1527 }
1528 
do_register_framebuffer(struct fb_info * fb_info)1529 static int do_register_framebuffer(struct fb_info *fb_info)
1530 {
1531 	int i;
1532 	struct fb_videomode mode;
1533 
1534 	if (fb_check_foreignness(fb_info))
1535 		return -ENOSYS;
1536 
1537 	if (num_registered_fb == FB_MAX)
1538 		return -ENXIO;
1539 
1540 	num_registered_fb++;
1541 	for (i = 0 ; i < FB_MAX; i++)
1542 		if (!registered_fb[i])
1543 			break;
1544 	fb_info->node = i;
1545 	refcount_set(&fb_info->count, 1);
1546 	mutex_init(&fb_info->lock);
1547 	mutex_init(&fb_info->mm_lock);
1548 
1549 	fb_info->dev = device_create(fb_class, fb_info->device,
1550 				     MKDEV(FB_MAJOR, i), NULL, "fb%d", i);
1551 	if (IS_ERR(fb_info->dev)) {
1552 		/* Not fatal */
1553 		printk(KERN_WARNING "Unable to create device for framebuffer %d; errno = %ld\n", i, PTR_ERR(fb_info->dev));
1554 		fb_info->dev = NULL;
1555 	} else
1556 		fb_init_device(fb_info);
1557 
1558 	if (fb_info->pixmap.addr == NULL) {
1559 		fb_info->pixmap.addr = kmalloc(FBPIXMAPSIZE, GFP_KERNEL);
1560 		if (fb_info->pixmap.addr) {
1561 			fb_info->pixmap.size = FBPIXMAPSIZE;
1562 			fb_info->pixmap.buf_align = 1;
1563 			fb_info->pixmap.scan_align = 1;
1564 			fb_info->pixmap.access_align = 32;
1565 			fb_info->pixmap.flags = FB_PIXMAP_DEFAULT;
1566 		}
1567 	}
1568 	fb_info->pixmap.offset = 0;
1569 
1570 	if (!fb_info->pixmap.blit_x)
1571 		fb_info->pixmap.blit_x = ~(u32)0;
1572 
1573 	if (!fb_info->pixmap.blit_y)
1574 		fb_info->pixmap.blit_y = ~(u32)0;
1575 
1576 	if (!fb_info->modelist.prev || !fb_info->modelist.next)
1577 		INIT_LIST_HEAD(&fb_info->modelist);
1578 
1579 	if (fb_info->skip_vt_switch)
1580 		pm_vt_switch_required(fb_info->dev, false);
1581 	else
1582 		pm_vt_switch_required(fb_info->dev, true);
1583 
1584 	fb_var_to_videomode(&mode, &fb_info->var);
1585 	fb_add_videomode(&mode, &fb_info->modelist);
1586 	registered_fb[i] = fb_info;
1587 
1588 #ifdef CONFIG_GUMSTIX_AM200EPD
1589 	{
1590 		struct fb_event event;
1591 		event.info = fb_info;
1592 		fb_notifier_call_chain(FB_EVENT_FB_REGISTERED, &event);
1593 	}
1594 #endif
1595 
1596 	return fbcon_fb_registered(fb_info);
1597 }
1598 
unbind_console(struct fb_info * fb_info)1599 static void unbind_console(struct fb_info *fb_info)
1600 {
1601 	int i = fb_info->node;
1602 
1603 	if (WARN_ON(i < 0 || i >= FB_MAX || registered_fb[i] != fb_info))
1604 		return;
1605 
1606 	fbcon_fb_unbind(fb_info);
1607 }
1608 
unlink_framebuffer(struct fb_info * fb_info)1609 static void unlink_framebuffer(struct fb_info *fb_info)
1610 {
1611 	int i;
1612 
1613 	i = fb_info->node;
1614 	if (WARN_ON(i < 0 || i >= FB_MAX || registered_fb[i] != fb_info))
1615 		return;
1616 
1617 	if (!fb_info->dev)
1618 		return;
1619 
1620 	device_destroy(fb_class, MKDEV(FB_MAJOR, i));
1621 
1622 	pm_vt_switch_unregister(fb_info->dev);
1623 
1624 	unbind_console(fb_info);
1625 
1626 	fb_info->dev = NULL;
1627 }
1628 
do_unregister_framebuffer(struct fb_info * fb_info)1629 static void do_unregister_framebuffer(struct fb_info *fb_info)
1630 {
1631 	unlink_framebuffer(fb_info);
1632 	if (fb_info->pixmap.addr &&
1633 	    (fb_info->pixmap.flags & FB_PIXMAP_DEFAULT)) {
1634 		kfree(fb_info->pixmap.addr);
1635 		fb_info->pixmap.addr = NULL;
1636 	}
1637 
1638 	fb_destroy_modelist(&fb_info->modelist);
1639 	registered_fb[fb_info->node] = NULL;
1640 	num_registered_fb--;
1641 	fb_cleanup_device(fb_info);
1642 #ifdef CONFIG_GUMSTIX_AM200EPD
1643 	{
1644 		struct fb_event event;
1645 		event.info = fb_info;
1646 		fb_notifier_call_chain(FB_EVENT_FB_UNREGISTERED, &event);
1647 	}
1648 #endif
1649 	fbcon_fb_unregistered(fb_info);
1650 
1651 	/* this may free fb info */
1652 	put_fb_info(fb_info);
1653 }
1654 
fb_aperture_acquire_for_platform_device(struct fb_info * fb_info)1655 static int fb_aperture_acquire_for_platform_device(struct fb_info *fb_info)
1656 {
1657 	struct apertures_struct *ap = fb_info->apertures;
1658 	struct device *dev = fb_info->device;
1659 	struct platform_device *pdev;
1660 	unsigned int i;
1661 	int ret;
1662 
1663 	if (!ap)
1664 		return 0;
1665 
1666 	if (!dev_is_platform(dev))
1667 		return 0;
1668 
1669 	pdev = to_platform_device(dev);
1670 
1671 	for (ret = 0, i = 0; i < ap->count; ++i) {
1672 		ret = devm_aperture_acquire_for_platform_device(pdev, ap->ranges[i].base,
1673 								ap->ranges[i].size);
1674 		if (ret)
1675 			break;
1676 	}
1677 
1678 	return ret;
1679 }
1680 
1681 /**
1682  *	register_framebuffer - registers a frame buffer device
1683  *	@fb_info: frame buffer info structure
1684  *
1685  *	Registers a frame buffer device @fb_info.
1686  *
1687  *	Returns negative errno on error, or zero for success.
1688  *
1689  */
1690 int
register_framebuffer(struct fb_info * fb_info)1691 register_framebuffer(struct fb_info *fb_info)
1692 {
1693 	int ret;
1694 
1695 	if (fb_info->flags & FBINFO_MISC_FIRMWARE) {
1696 		ret = fb_aperture_acquire_for_platform_device(fb_info);
1697 		if (ret)
1698 			return ret;
1699 	}
1700 
1701 	mutex_lock(&registration_lock);
1702 	ret = do_register_framebuffer(fb_info);
1703 	mutex_unlock(&registration_lock);
1704 
1705 	return ret;
1706 }
1707 EXPORT_SYMBOL(register_framebuffer);
1708 
1709 /**
1710  *	unregister_framebuffer - releases a frame buffer device
1711  *	@fb_info: frame buffer info structure
1712  *
1713  *	Unregisters a frame buffer device @fb_info.
1714  *
1715  *	Returns negative errno on error, or zero for success.
1716  *
1717  *      This function will also notify the framebuffer console
1718  *      to release the driver.
1719  *
1720  *      This is meant to be called within a driver's module_exit()
1721  *      function. If this is called outside module_exit(), ensure
1722  *      that the driver implements fb_open() and fb_release() to
1723  *      check that no processes are using the device.
1724  */
1725 void
unregister_framebuffer(struct fb_info * fb_info)1726 unregister_framebuffer(struct fb_info *fb_info)
1727 {
1728 	mutex_lock(&registration_lock);
1729 	do_unregister_framebuffer(fb_info);
1730 	mutex_unlock(&registration_lock);
1731 }
1732 EXPORT_SYMBOL(unregister_framebuffer);
1733 
1734 /**
1735  *	fb_set_suspend - low level driver signals suspend
1736  *	@info: framebuffer affected
1737  *	@state: 0 = resuming, !=0 = suspending
1738  *
1739  *	This is meant to be used by low level drivers to
1740  * 	signal suspend/resume to the core & clients.
1741  *	It must be called with the console semaphore held
1742  */
fb_set_suspend(struct fb_info * info,int state)1743 void fb_set_suspend(struct fb_info *info, int state)
1744 {
1745 	WARN_CONSOLE_UNLOCKED();
1746 
1747 	if (state) {
1748 		fbcon_suspended(info);
1749 		info->state = FBINFO_STATE_SUSPENDED;
1750 	} else {
1751 		info->state = FBINFO_STATE_RUNNING;
1752 		fbcon_resumed(info);
1753 	}
1754 }
1755 EXPORT_SYMBOL(fb_set_suspend);
1756 
1757 /**
1758  *	fbmem_init - init frame buffer subsystem
1759  *
1760  *	Initialize the frame buffer subsystem.
1761  *
1762  *	NOTE: This function is _only_ to be called by drivers/char/mem.c.
1763  *
1764  */
1765 
1766 static int __init
fbmem_init(void)1767 fbmem_init(void)
1768 {
1769 	int ret;
1770 
1771 	if (!proc_create_seq("fb", 0, NULL, &proc_fb_seq_ops))
1772 		return -ENOMEM;
1773 
1774 	ret = register_chrdev(FB_MAJOR, "fb", &fb_fops);
1775 	if (ret) {
1776 		printk("unable to get major %d for fb devs\n", FB_MAJOR);
1777 		goto err_chrdev;
1778 	}
1779 
1780 	fb_class = class_create(THIS_MODULE, "graphics");
1781 	if (IS_ERR(fb_class)) {
1782 		ret = PTR_ERR(fb_class);
1783 		pr_warn("Unable to create fb class; errno = %d\n", ret);
1784 		fb_class = NULL;
1785 		goto err_class;
1786 	}
1787 
1788 	fb_console_init();
1789 
1790 	return 0;
1791 
1792 err_class:
1793 	unregister_chrdev(FB_MAJOR, "fb");
1794 err_chrdev:
1795 	remove_proc_entry("fb", NULL);
1796 	return ret;
1797 }
1798 
1799 #ifdef MODULE
1800 module_init(fbmem_init);
1801 static void __exit
fbmem_exit(void)1802 fbmem_exit(void)
1803 {
1804 	fb_console_exit();
1805 
1806 	remove_proc_entry("fb", NULL);
1807 	class_destroy(fb_class);
1808 	unregister_chrdev(FB_MAJOR, "fb");
1809 }
1810 
1811 module_exit(fbmem_exit);
1812 MODULE_LICENSE("GPL");
1813 MODULE_DESCRIPTION("Framebuffer base");
1814 #else
1815 subsys_initcall(fbmem_init);
1816 #endif
1817 
fb_new_modelist(struct fb_info * info)1818 int fb_new_modelist(struct fb_info *info)
1819 {
1820 	struct fb_var_screeninfo var = info->var;
1821 	struct list_head *pos, *n;
1822 	struct fb_modelist *modelist;
1823 	struct fb_videomode *m, mode;
1824 	int err;
1825 
1826 	list_for_each_safe(pos, n, &info->modelist) {
1827 		modelist = list_entry(pos, struct fb_modelist, list);
1828 		m = &modelist->mode;
1829 		fb_videomode_to_var(&var, m);
1830 		var.activate = FB_ACTIVATE_TEST;
1831 		err = fb_set_var(info, &var);
1832 		fb_var_to_videomode(&mode, &var);
1833 		if (err || !fb_mode_is_equal(m, &mode)) {
1834 			list_del(pos);
1835 			kfree(pos);
1836 		}
1837 	}
1838 
1839 	if (list_empty(&info->modelist))
1840 		return 1;
1841 
1842 	fbcon_new_modelist(info);
1843 
1844 	return 0;
1845 }
1846 
1847 MODULE_LICENSE("GPL");
1848