1	/*
2	* linux/drivers/video/fbcon.c -- Low level frame buffer based console driver
3	*
4	* Copyright (C) 1995 Geert Uytterhoeven
5	*
6	*
7	* This file is based on the original Amiga console driver (amicon.c):
8	*
9	* Copyright (C) 1993 Hamish Macdonald
10	* Greg Harp
11	* Copyright (C) 1994 David Carter [carter@compsci.bristol.ac.uk]
12	*
13	* with work by William Rucklidge (wjr@cs.cornell.edu)
14	* Geert Uytterhoeven
15	* Jes Sorensen (jds@kom.auc.dk)
16	* Martin Apel
17	*
18	* and on the original Atari console driver (atacon.c):
19	*
20	* Copyright (C) 1993 Bjoern Brauel
21	* Roman Hodek
22	*
23	* with work by Guenther Kelleter
24	* Martin Schaller
25	* Andreas Schwab
26	*
27	* Hardware cursor support added by Emmanuel Marty (core@ggi-project.org)
28	* Smart redraw scrolling, arbitrary font width support, 512char font support
29	* and software scrollback added by
30	* Jakub Jelinek (jj@ultra.linux.cz)
31	*
32	* Random hacking by Martin Mares <mj@ucw.cz>
33	*
34	* 2001 - Documented with DocBook
35	* - Brad Douglas <brad@neruo.com>
36	*
37	* The low level operations for the various display memory organizations are
38	* now in separate source files.
39	*
40	* Currently the following organizations are supported:
41	*
42	* o afb Amiga bitplanes
43	* o cfb{2,4,8,16,24,32} Packed pixels
44	* o ilbm Amiga interleaved bitplanes
45	* o iplan2p[248] Atari interleaved bitplanes
46	* o mfb Monochrome
47	* o vga VGA characters/attributes
48	*
49	* To do:
50	*
51	* - Implement 16 plane mode (iplan2p16)
52	*
53	*
54	* This file is subject to the terms and conditions of the GNU General Public
55	* License. See the file COPYING in the main directory of this archive for
56	* more details.
57	*/
58
59	#include <linux/module.h>
60	#include <linux/types.h>
61	#include <linux/fs.h>
62	#include <linux/kernel.h>
63	#include <linux/delay.h> /* MSch: for IRQ probe */
64	#include <linux/console.h>
65	#include <linux/string.h>
66	#include <linux/kd.h>
67	#include <linux/slab.h>
68	#include <linux/fb.h>
69	#include <linux/fbcon.h>
70	#include <linux/vt_kern.h>
71	#include <linux/selection.h>
72	#include <linux/font.h>
73	#include <linux/smp.h>
74	#include <linux/init.h>
75	#include <linux/interrupt.h>
76	#include <linux/crc32.h> /* For counting font checksums */
77	#include <linux/uaccess.h>
78	#include <asm/irq.h>
79
80	#include "fbcon.h"
81	#include "fb_internal.h"
82
83	/*
84	* FIXME: Locking
85	*
86	* - fbcon state itself is protected by the console_lock, and the code does a
87	* pretty good job at making sure that lock is held everywhere it's needed.
88	*
89	* - fbcon doesn't bother with fb_lock/unlock at all. This is buggy, since it
90	* means concurrent access to the same fbdev from both fbcon and userspace
91	* will blow up. To fix this all fbcon calls from fbmem.c need to be moved out
92	* of fb_lock/unlock protected sections, since otherwise we'll recurse and
93	* deadlock eventually. Aside: Due to these deadlock issues the fbdev code in
94	* fbmem.c cannot use locking asserts, and there's lots of callers which get
95	* the rules wrong, e.g. fbsysfs.c entirely missed fb_lock/unlock calls too.
96	*/
97
98	enum {
99	FBCON_LOGO_CANSHOW = -1, /* the logo can be shown */
100	FBCON_LOGO_DRAW = -2, /* draw the logo to a console */
101	FBCON_LOGO_DONTSHOW = -3 /* do not show the logo */
102	};
103
104	static struct fbcon_display fb_display[MAX_NR_CONSOLES];
105
106	static struct fb_info *fbcon_registered_fb[FB_MAX];
107	static int fbcon_num_registered_fb;
108
109	#define fbcon_for_each_registered_fb(i) \
110	for (i = 0; WARN_CONSOLE_UNLOCKED(), i < FB_MAX; i++) \
111	if (!fbcon_registered_fb[i]) {} else
112
113	static signed char con2fb_map[MAX_NR_CONSOLES];
114	static signed char con2fb_map_boot[MAX_NR_CONSOLES];
115
116	static struct fb_info *fbcon_info_from_console(int console)
117	{
118	WARN_CONSOLE_UNLOCKED();
119
120	return fbcon_registered_fb[con2fb_map[console]];
121	}
122
123	static int logo_lines;
124	/* logo_shown is an index to vc_cons when >= 0; otherwise follows FBCON_LOGO
125	enums. */
126	static int logo_shown = FBCON_LOGO_CANSHOW;
127	/* console mappings */
128	static unsigned int first_fb_vc;
129	static unsigned int last_fb_vc = MAX_NR_CONSOLES - 1;
130	static int fbcon_is_default = 1;
131	static int primary_device = -1;
132	static int fbcon_has_console_bind;
133
134	#ifdef CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY
135	static int map_override;
136
137	static inline void fbcon_map_override(void)
138	{
139	map_override = 1;
140	}
141	#else
142	static inline void fbcon_map_override(void)
143	{
144	}
145	#endif /* CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY */
146
147	#ifdef CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER
148	static bool deferred_takeover = true;
149	#else
150	#define deferred_takeover false
151	#endif
152
153	/* font data */
154	static char fontname[40];
155
156	/* current fb_info */
157	static int info_idx = -1;
158
159	/* console rotation */
160	static int initial_rotation = -1;
161	static int fbcon_has_sysfs;
162	static int margin_color;
163
164	static const struct consw fb_con;
165
166	#define advance_row(p, delta) (unsigned short *)((unsigned long)(p) + (delta) * vc->vc_size_row)
167
168	static int fbcon_cursor_noblink;
169
170	#define divides(a, b) ((!(a) || (b)%(a)) ? 0 : 1)
171
172	/*
173	* Interface used by the world
174	*/
175
176	static void fbcon_clear_margins(struct vc_data *vc, int bottom_only);
177	static void fbcon_set_palette(struct vc_data *vc, const unsigned char *table);
178
179	/*
180	* Internal routines
181	*/
182	static void fbcon_set_disp(struct fb_info *info, struct fb_var_screeninfo *var,
183	int unit);
184	static void fbcon_redraw_move(struct vc_data *vc, struct fbcon_display *p,
185	int line, int count, int dy);
186	static void fbcon_modechanged(struct fb_info *info);
187	static void fbcon_set_all_vcs(struct fb_info *info);
188
189	static struct device *fbcon_device;
190
191	#ifdef CONFIG_FRAMEBUFFER_CONSOLE_ROTATION
192	static inline void fbcon_set_rotation(struct fb_info *info)
193	{
194	struct fbcon_ops *ops = info->fbcon_par;
195
196	if (!(info->flags & FBINFO_MISC_TILEBLITTING) &&
197	ops->p->con_rotate < 4)
198	ops->rotate = ops->p->con_rotate;
199	else
200	ops->rotate = 0;
201	}
202
203	static void fbcon_rotate(struct fb_info *info, u32 rotate)
204	{
205	struct fbcon_ops *ops= info->fbcon_par;
206	struct fb_info *fb_info;
207
208	if (!ops || ops->currcon == -1)
209	return;
210
211	fb_info = fbcon_info_from_console(console: ops->currcon);
212
213	if (info == fb_info) {
214	struct fbcon_display *p = &fb_display[ops->currcon];
215
216	if (rotate < 4)
217	p->con_rotate = rotate;
218	else
219	p->con_rotate = 0;
220
221	fbcon_modechanged(info);
222	}
223	}
224
225	static void fbcon_rotate_all(struct fb_info *info, u32 rotate)
226	{
227	struct fbcon_ops *ops = info->fbcon_par;
228	struct vc_data *vc;
229	struct fbcon_display *p;
230	int i;
231
232	if (!ops || ops->currcon < 0 || rotate > 3)
233	return;
234
235	for (i = first_fb_vc; i <= last_fb_vc; i++) {
236	vc = vc_cons[i].d;
237	if (!vc || vc->vc_mode != KD_TEXT ||
238	fbcon_info_from_console(console: i) != info)
239	continue;
240
241	p = &fb_display[vc->vc_num];
242	p->con_rotate = rotate;
243	}
244
245	fbcon_set_all_vcs(info);
246	}
247	#else
248	static inline void fbcon_set_rotation(struct fb_info *info)
249	{
250	struct fbcon_ops *ops = info->fbcon_par;
251
252	ops->rotate = FB_ROTATE_UR;
253	}
254
255	static void fbcon_rotate(struct fb_info *info, u32 rotate)
256	{
257	return;
258	}
259
260	static void fbcon_rotate_all(struct fb_info *info, u32 rotate)
261	{
262	return;
263	}
264	#endif /* CONFIG_FRAMEBUFFER_CONSOLE_ROTATION */
265
266	static int fbcon_get_rotate(struct fb_info *info)
267	{
268	struct fbcon_ops *ops = info->fbcon_par;
269
270	return (ops) ? ops->rotate : 0;
271	}
272
273	static inline int fbcon_is_inactive(struct vc_data *vc, struct fb_info *info)
274	{
275	struct fbcon_ops *ops = info->fbcon_par;
276
277	return (info->state != FBINFO_STATE_RUNNING ||
278	vc->vc_mode != KD_TEXT || ops->graphics);
279	}
280
281	static int get_color(struct vc_data *vc, struct fb_info *info,
282	u16 c, int is_fg)
283	{
284	int depth = fb_get_color_depth(var: &info->var, fix: &info->fix);
285	int color = 0;
286
287	if (console_blanked) {
288	unsigned short charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff;
289
290	c = vc->vc_video_erase_char & charmask;
291	}
292
293	if (depth != 1)
294	color = (is_fg) ? attr_fgcol((vc->vc_hi_font_mask) ? 9 : 8, c)
295	: attr_bgcol((vc->vc_hi_font_mask) ? 13 : 12, c);
296
297	switch (depth) {
298	case 1:
299	{
300	int col = mono_col(info);
301	/* 0 or 1 */
302	int fg = (info->fix.visual != FB_VISUAL_MONO01) ? col : 0;
303	int bg = (info->fix.visual != FB_VISUAL_MONO01) ? 0 : col;
304
305	if (console_blanked)
306	fg = bg;
307
308	color = (is_fg) ? fg : bg;
309	break;
310	}
311	case 2:
312	/*
313	* Scale down 16-colors to 4 colors. Default 4-color palette
314	* is grayscale. However, simply dividing the values by 4
315	* will not work, as colors 1, 2 and 3 will be scaled-down
316	* to zero rendering them invisible. So empirically convert
317	* colors to a sane 4-level grayscale.
318	*/
319	switch (color) {
320	case 0:
321	color = 0; /* black */
322	break;
323	case 1 ... 6:
324	color = 2; /* white */
325	break;
326	case 7 ... 8:
327	color = 1; /* gray */
328	break;
329	default:
330	color = 3; /* intense white */
331	break;
332	}
333	break;
334	case 3:
335	/*
336	* Last 8 entries of default 16-color palette is a more intense
337	* version of the first 8 (i.e., same chrominance, different
338	* luminance).
339	*/
340	color &= 7;
341	break;
342	}
343
344
345	return color;
346	}
347
348	static void fb_flashcursor(struct work_struct *work)
349	{
350	struct fbcon_ops *ops = container_of(work, struct fbcon_ops, cursor_work.work);
351	struct fb_info *info;
352	struct vc_data *vc = NULL;
353	int c;
354	int mode;
355	int ret;
356
357	/* FIXME: we should sort out the unbind locking instead */
358	/* instead we just fail to flash the cursor if we can't get
359	* the lock instead of blocking fbcon deinit */
360	ret = console_trylock();
361	if (ret == 0)
362	return;
363
364	/* protected by console_lock */
365	info = ops->info;
366
367	if (ops->currcon != -1)
368	vc = vc_cons[ops->currcon].d;
369
370	if (!vc || !con_is_visible(vc) ||
371	fbcon_info_from_console(console: vc->vc_num) != info ||
372	vc->vc_deccm != 1) {
373	console_unlock();
374	return;
375	}
376
377	c = scr_readw((u16 *) vc->vc_pos);
378	mode = (!ops->cursor_flash || ops->cursor_state.enable) ?
379	CM_ERASE : CM_DRAW;
380	ops->cursor(vc, info, mode, get_color(vc, info, c, is_fg: 1),
381	get_color(vc, info, c, is_fg: 0));
382	console_unlock();
383
384	queue_delayed_work(wq: system_power_efficient_wq, dwork: &ops->cursor_work,
385	delay: ops->cur_blink_jiffies);
386	}
387
388	static void fbcon_add_cursor_work(struct fb_info *info)
389	{
390	struct fbcon_ops *ops = info->fbcon_par;
391
392	if (!fbcon_cursor_noblink)
393	queue_delayed_work(wq: system_power_efficient_wq, dwork: &ops->cursor_work,
394	delay: ops->cur_blink_jiffies);
395	}
396
397	static void fbcon_del_cursor_work(struct fb_info *info)
398	{
399	struct fbcon_ops *ops = info->fbcon_par;
400
401	cancel_delayed_work_sync(dwork: &ops->cursor_work);
402	}
403
404	#ifndef MODULE
405	static int __init fb_console_setup(char *this_opt)
406	{
407	char *options;
408	int i, j;
409
410	if (!this_opt || !*this_opt)
411	return 1;
412
413	while ((options = strsep(&this_opt, ",")) != NULL) {
414	if (!strncmp(options, "font:", 5)) {
415	strscpy(p: fontname, q: options + 5, size: sizeof(fontname));
416	continue;
417	}
418
419	if (!strncmp(options, "scrollback:", 11)) {
420	pr_warn("Ignoring scrollback size option\n");
421	continue;
422	}
423
424	if (!strncmp(options, "map:", 4)) {
425	options += 4;
426	if (*options) {
427	for (i = 0, j = 0; i < MAX_NR_CONSOLES; i++) {
428	if (!options[j])
429	j = 0;
430	con2fb_map_boot[i] =
431	(options[j++]-'0') % FB_MAX;
432	}
433
434	fbcon_map_override();
435	}
436	continue;
437	}
438
439	if (!strncmp(options, "vc:", 3)) {
440	options += 3;
441	if (*options)
442	first_fb_vc = simple_strtoul(options, &options, 10) - 1;
443	if (first_fb_vc >= MAX_NR_CONSOLES)
444	first_fb_vc = 0;
445	if (*options++ == '-')
446	last_fb_vc = simple_strtoul(options, &options, 10) - 1;
447	if (last_fb_vc < first_fb_vc || last_fb_vc >= MAX_NR_CONSOLES)
448	last_fb_vc = MAX_NR_CONSOLES - 1;
449	fbcon_is_default = 0;
450	continue;
451	}
452
453	if (!strncmp(options, "rotate:", 7)) {
454	options += 7;
455	if (*options)
456	initial_rotation = simple_strtoul(options, &options, 0);
457	if (initial_rotation > 3)
458	initial_rotation = 0;
459	continue;
460	}
461
462	if (!strncmp(options, "margin:", 7)) {
463	options += 7;
464	if (*options)
465	margin_color = simple_strtoul(options, &options, 0);
466	continue;
467	}
468	#ifdef CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER
469	if (!strcmp(options, "nodefer")) {
470	deferred_takeover = false;
471	continue;
472	}
473	#endif
474
475	#ifdef CONFIG_LOGO
476	if (!strncmp(options, "logo-pos:", 9)) {
477	options += 9;
478	if (!strcmp(options, "center"))
479	fb_center_logo = true;
480	continue;
481	}
482
483	if (!strncmp(options, "logo-count:", 11)) {
484	options += 11;
485	if (*options)
486	fb_logo_count = simple_strtol(options, &options, 0);
487	continue;
488	}
489	#endif
490	}
491	return 1;
492	}
493
494	__setup("fbcon=", fb_console_setup);
495	#endif
496
497	static int search_fb_in_map(int idx)
498	{
499	int i, retval = 0;
500
501	for (i = first_fb_vc; i <= last_fb_vc; i++) {
502	if (con2fb_map[i] == idx)
503	retval = 1;
504	}
505	return retval;
506	}
507
508	static int search_for_mapped_con(void)
509	{
510	int i, retval = 0;
511
512	for (i = first_fb_vc; i <= last_fb_vc; i++) {
513	if (con2fb_map[i] != -1)
514	retval = 1;
515	}
516	return retval;
517	}
518
519	static int do_fbcon_takeover(int show_logo)
520	{
521	int err, i;
522
523	if (!fbcon_num_registered_fb)
524	return -ENODEV;
525
526	if (!show_logo)
527	logo_shown = FBCON_LOGO_DONTSHOW;
528
529	for (i = first_fb_vc; i <= last_fb_vc; i++)
530	con2fb_map[i] = info_idx;
531
532	err = do_take_over_console(sw: &fb_con, first: first_fb_vc, last: last_fb_vc,
533	deflt: fbcon_is_default);
534
535	if (err) {
536	for (i = first_fb_vc; i <= last_fb_vc; i++)
537	con2fb_map[i] = -1;
538	info_idx = -1;
539	} else {
540	fbcon_has_console_bind = 1;
541	}
542
543	return err;
544	}
545
546	#ifdef MODULE
547	static void fbcon_prepare_logo(struct vc_data *vc, struct fb_info *info,
548	int cols, int rows, int new_cols, int new_rows)
549	{
550	logo_shown = FBCON_LOGO_DONTSHOW;
551	}
552	#else
553	static void fbcon_prepare_logo(struct vc_data *vc, struct fb_info *info,
554	int cols, int rows, int new_cols, int new_rows)
555	{
556	/* Need to make room for the logo */
557	struct fbcon_ops *ops = info->fbcon_par;
558	int cnt, erase = vc->vc_video_erase_char, step;
559	unsigned short *save = NULL, *r, *q;
560	int logo_height;
561
562	if (info->fbops->owner) {
563	logo_shown = FBCON_LOGO_DONTSHOW;
564	return;
565	}
566
567	/*
568	* remove underline attribute from erase character
569	* if black and white framebuffer.
570	*/
571	if (fb_get_color_depth(var: &info->var, fix: &info->fix) == 1)
572	erase &= ~0x400;
573	logo_height = fb_prepare_logo(fb_info: info, rotate: ops->rotate);
574	logo_lines = DIV_ROUND_UP(logo_height, vc->vc_font.height);
575	q = (unsigned short *) (vc->vc_origin +
576	vc->vc_size_row * rows);
577	step = logo_lines * cols;
578	for (r = q - logo_lines * cols; r < q; r++)
579	if (scr_readw(r) != vc->vc_video_erase_char)
580	break;
581	if (r != q && new_rows >= rows + logo_lines) {
582	save = kmalloc(array3_size(logo_lines, new_cols, 2),
583	GFP_KERNEL);
584	if (save) {
585	int i = min(cols, new_cols);
586	scr_memsetw(s: save, c: erase, array3_size(logo_lines, new_cols, 2));
587	r = q - step;
588	for (cnt = 0; cnt < logo_lines; cnt++, r += i)
589	scr_memcpyw(d: save + cnt * new_cols, s: r, count: 2 * i);
590	r = q;
591	}
592	}
593	if (r == q) {
594	/* We can scroll screen down */
595	r = q - step - cols;
596	for (cnt = rows - logo_lines; cnt > 0; cnt--) {
597	scr_memcpyw(d: r + step, s: r, count: vc->vc_size_row);
598	r -= cols;
599	}
600	if (!save) {
601	int lines;
602	if (vc->state.y + logo_lines >= rows)
603	lines = rows - vc->state.y - 1;
604	else
605	lines = logo_lines;
606	vc->state.y += lines;
607	vc->vc_pos += lines * vc->vc_size_row;
608	}
609	}
610	scr_memsetw(s: (unsigned short *) vc->vc_origin,
611	c: erase,
612	count: vc->vc_size_row * logo_lines);
613
614	if (con_is_visible(vc) && vc->vc_mode == KD_TEXT) {
615	fbcon_clear_margins(vc, bottom_only: 0);
616	update_screen(vc);
617	}
618
619	if (save) {
620	q = (unsigned short *) (vc->vc_origin +
621	vc->vc_size_row *
622	rows);
623	scr_memcpyw(d: q, s: save, array3_size(logo_lines, new_cols, 2));
624	vc->state.y += logo_lines;
625	vc->vc_pos += logo_lines * vc->vc_size_row;
626	kfree(objp: save);
627	}
628
629	if (logo_shown == FBCON_LOGO_DONTSHOW)
630	return;
631
632	if (logo_lines > vc->vc_bottom) {
633	logo_shown = FBCON_LOGO_CANSHOW;
634	printk(KERN_INFO
635	"fbcon_init: disable boot-logo (boot-logo bigger than screen).\n");
636	} else {
637	logo_shown = FBCON_LOGO_DRAW;
638	vc->vc_top = logo_lines;
639	}
640	}
641	#endif /* MODULE */
642
643	#ifdef CONFIG_FB_TILEBLITTING
644	static void set_blitting_type(struct vc_data *vc, struct fb_info *info)
645	{
646	struct fbcon_ops *ops = info->fbcon_par;
647
648	ops->p = &fb_display[vc->vc_num];
649
650	if ((info->flags & FBINFO_MISC_TILEBLITTING))
651	fbcon_set_tileops(vc, info);
652	else {
653	fbcon_set_rotation(info);
654	fbcon_set_bitops(ops);
655	}
656	}
657
658	static int fbcon_invalid_charcount(struct fb_info *info, unsigned charcount)
659	{
660	int err = 0;
661
662	if (info->flags & FBINFO_MISC_TILEBLITTING &&
663	info->tileops->fb_get_tilemax(info) < charcount)
664	err = 1;
665
666	return err;
667	}
668	#else
669	static void set_blitting_type(struct vc_data *vc, struct fb_info *info)
670	{
671	struct fbcon_ops *ops = info->fbcon_par;
672
673	info->flags &= ~FBINFO_MISC_TILEBLITTING;
674	ops->p = &fb_display[vc->vc_num];
675	fbcon_set_rotation(info);
676	fbcon_set_bitops(ops);
677	}
678
679	static int fbcon_invalid_charcount(struct fb_info *info, unsigned charcount)
680	{
681	return 0;
682	}
683
684	#endif /* CONFIG_MISC_TILEBLITTING */
685
686	static void fbcon_release(struct fb_info *info)
687	{
688	lock_fb_info(info);
689	if (info->fbops->fb_release)
690	info->fbops->fb_release(info, 0);
691	unlock_fb_info(info);
692
693	module_put(module: info->fbops->owner);
694
695	if (info->fbcon_par) {
696	struct fbcon_ops *ops = info->fbcon_par;
697
698	fbcon_del_cursor_work(info);
699	kfree(objp: ops->cursor_state.mask);
700	kfree(objp: ops->cursor_data);
701	kfree(objp: ops->cursor_src);
702	kfree(objp: ops->fontbuffer);
703	kfree(objp: info->fbcon_par);
704	info->fbcon_par = NULL;
705	}
706	}
707
708	static int fbcon_open(struct fb_info *info)
709	{
710	struct fbcon_ops *ops;
711
712	if (!try_module_get(module: info->fbops->owner))
713	return -ENODEV;
714
715	lock_fb_info(info);
716	if (info->fbops->fb_open &&
717	info->fbops->fb_open(info, 0)) {
718	unlock_fb_info(info);
719	module_put(module: info->fbops->owner);
720	return -ENODEV;
721	}
722	unlock_fb_info(info);
723
724	ops = kzalloc(size: sizeof(struct fbcon_ops), GFP_KERNEL);
725	if (!ops) {
726	fbcon_release(info);
727	return -ENOMEM;
728	}
729
730	INIT_DELAYED_WORK(&ops->cursor_work, fb_flashcursor);
731	ops->info = info;
732	info->fbcon_par = ops;
733	ops->cur_blink_jiffies = HZ / 5;
734
735	return 0;
736	}
737
738	static int con2fb_acquire_newinfo(struct vc_data *vc, struct fb_info *info,
739	int unit)
740	{
741	int err;
742
743	err = fbcon_open(info);
744	if (err)
745	return err;
746
747	if (vc)
748	set_blitting_type(vc, info);
749
750	return err;
751	}
752
753	static void con2fb_release_oldinfo(struct vc_data *vc, struct fb_info *oldinfo,
754	struct fb_info *newinfo)
755	{
756	int ret;
757
758	fbcon_release(info: oldinfo);
759
760	/*
761	If oldinfo and newinfo are driving the same hardware,
762	the fb_release() method of oldinfo may attempt to
763	restore the hardware state. This will leave the
764	newinfo in an undefined state. Thus, a call to
765	fb_set_par() may be needed for the newinfo.
766	*/
767	if (newinfo && newinfo->fbops->fb_set_par) {
768	ret = newinfo->fbops->fb_set_par(newinfo);
769
770	if (ret)
771	printk(KERN_ERR "con2fb_release_oldinfo: "
772	"detected unhandled fb_set_par error, "
773	"error code %d\n", ret);
774	}
775	}
776
777	static void con2fb_init_display(struct vc_data *vc, struct fb_info *info,
778	int unit, int show_logo)
779	{
780	struct fbcon_ops *ops = info->fbcon_par;
781	int ret;
782
783	ops->currcon = fg_console;
784
785	if (info->fbops->fb_set_par && !ops->initialized) {
786	ret = info->fbops->fb_set_par(info);
787
788	if (ret)
789	printk(KERN_ERR "con2fb_init_display: detected "
790	"unhandled fb_set_par error, "
791	"error code %d\n", ret);
792	}
793
794	ops->initialized = true;
795	ops->graphics = 0;
796	fbcon_set_disp(info, var: &info->var, unit);
797
798	if (show_logo) {
799	struct vc_data *fg_vc = vc_cons[fg_console].d;
800	struct fb_info *fg_info =
801	fbcon_info_from_console(console: fg_console);
802
803	fbcon_prepare_logo(vc: fg_vc, info: fg_info, cols: fg_vc->vc_cols,
804	rows: fg_vc->vc_rows, new_cols: fg_vc->vc_cols,
805	new_rows: fg_vc->vc_rows);
806	}
807
808	update_screen(vc_cons[fg_console].d);
809	}
810
811	/**
812	* set_con2fb_map - map console to frame buffer device
813	* @unit: virtual console number to map
814	* @newidx: frame buffer index to map virtual console to
815	* @user: user request
816	*
817	* Maps a virtual console @unit to a frame buffer device
818	* @newidx.
819	*
820	* This should be called with the console lock held.
821	*/
822	static int set_con2fb_map(int unit, int newidx, int user)
823	{
824	struct vc_data *vc = vc_cons[unit].d;
825	int oldidx = con2fb_map[unit];
826	struct fb_info *info = fbcon_registered_fb[newidx];
827	struct fb_info *oldinfo = NULL;
828	int err = 0, show_logo;
829
830	WARN_CONSOLE_UNLOCKED();
831
832	if (oldidx == newidx)
833	return 0;
834
835	if (!info)
836	return -EINVAL;
837
838	if (!search_for_mapped_con() || !con_is_bound(csw: &fb_con)) {
839	info_idx = newidx;
840	return do_fbcon_takeover(show_logo: 0);
841	}
842
843	if (oldidx != -1)
844	oldinfo = fbcon_registered_fb[oldidx];
845
846	if (!search_fb_in_map(idx: newidx)) {
847	err = con2fb_acquire_newinfo(vc, info, unit);
848	if (err)
849	return err;
850
851	fbcon_add_cursor_work(info);
852	}
853
854	con2fb_map[unit] = newidx;
855
856	/*
857	* If old fb is not mapped to any of the consoles,
858	* fbcon should release it.
859	*/
860	if (oldinfo && !search_fb_in_map(idx: oldidx))
861	con2fb_release_oldinfo(vc, oldinfo, newinfo: info);
862
863	show_logo = (fg_console == 0 && !user &&
864	logo_shown != FBCON_LOGO_DONTSHOW);
865
866	con2fb_map_boot[unit] = newidx;
867	con2fb_init_display(vc, info, unit, show_logo);
868
869	if (!search_fb_in_map(idx: info_idx))
870	info_idx = newidx;
871
872	return err;
873	}
874
875	/*
876	* Low Level Operations
877	*/
878	/* NOTE: fbcon cannot be __init: it may be called from do_take_over_console later */
879	static int var_to_display(struct fbcon_display *disp,
880	struct fb_var_screeninfo *var,
881	struct fb_info *info)
882	{
883	disp->xres_virtual = var->xres_virtual;
884	disp->yres_virtual = var->yres_virtual;
885	disp->bits_per_pixel = var->bits_per_pixel;
886	disp->grayscale = var->grayscale;
887	disp->nonstd = var->nonstd;
888	disp->accel_flags = var->accel_flags;
889	disp->height = var->height;
890	disp->width = var->width;
891	disp->red = var->red;
892	disp->green = var->green;
893	disp->blue = var->blue;
894	disp->transp = var->transp;
895	disp->rotate = var->rotate;
896	disp->mode = fb_match_mode(var, head: &info->modelist);
897	if (disp->mode == NULL)
898	/* This should not happen */
899	return -EINVAL;
900	return 0;
901	}
902
903	static void display_to_var(struct fb_var_screeninfo *var,
904	struct fbcon_display *disp)
905	{
906	fb_videomode_to_var(var, mode: disp->mode);
907	var->xres_virtual = disp->xres_virtual;
908	var->yres_virtual = disp->yres_virtual;
909	var->bits_per_pixel = disp->bits_per_pixel;
910	var->grayscale = disp->grayscale;
911	var->nonstd = disp->nonstd;
912	var->accel_flags = disp->accel_flags;
913	var->height = disp->height;
914	var->width = disp->width;
915	var->red = disp->red;
916	var->green = disp->green;
917	var->blue = disp->blue;
918	var->transp = disp->transp;
919	var->rotate = disp->rotate;
920	}
921
922	static const char *fbcon_startup(void)
923	{
924	const char *display_desc = "frame buffer device";
925	struct fbcon_display *p = &fb_display[fg_console];
926	struct vc_data *vc = vc_cons[fg_console].d;
927	const struct font_desc *font = NULL;
928	struct fb_info *info = NULL;
929	struct fbcon_ops *ops;
930	int rows, cols;
931
932	/*
933	* If num_registered_fb is zero, this is a call for the dummy part.
934	* The frame buffer devices weren't initialized yet.
935	*/
936	if (!fbcon_num_registered_fb || info_idx == -1)
937	return display_desc;
938	/*
939	* Instead of blindly using registered_fb[0], we use info_idx, set by
940	* fbcon_fb_registered();
941	*/
942	info = fbcon_registered_fb[info_idx];
943	if (!info)
944	return NULL;
945
946	if (fbcon_open(info))
947	return NULL;
948
949	ops = info->fbcon_par;
950	ops->currcon = -1;
951	ops->graphics = 1;
952	ops->cur_rotate = -1;
953
954	p->con_rotate = initial_rotation;
955	if (p->con_rotate == -1)
956	p->con_rotate = info->fbcon_rotate_hint;
957	if (p->con_rotate == -1)
958	p->con_rotate = FB_ROTATE_UR;
959
960	set_blitting_type(vc, info);
961
962	/* Setup default font */
963	if (!p->fontdata) {
964	if (!fontname[0] || !(font = find_font(name: fontname)))
965	font = get_default_font(xres: info->var.xres,
966	yres: info->var.yres,
967	font_w: info->pixmap.blit_x,
968	font_h: info->pixmap.blit_y);
969	vc->vc_font.width = font->width;
970	vc->vc_font.height = font->height;
971	vc->vc_font.data = (void *)(p->fontdata = font->data);
972	vc->vc_font.charcount = font->charcount;
973	}
974
975	cols = FBCON_SWAP(ops->rotate, info->var.xres, info->var.yres);
976	rows = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres);
977	cols /= vc->vc_font.width;
978	rows /= vc->vc_font.height;
979	vc_resize(vc, cols, lines: rows);
980
981	pr_debug("mode: %s\n", info->fix.id);
982	pr_debug("visual: %d\n", info->fix.visual);
983	pr_debug("res: %dx%d-%d\n", info->var.xres,
984	info->var.yres,
985	info->var.bits_per_pixel);
986
987	fbcon_add_cursor_work(info);
988	return display_desc;
989	}
990
991	static void fbcon_init(struct vc_data *vc, int init)
992	{
993	struct fb_info *info;
994	struct fbcon_ops *ops;
995	struct vc_data **default_mode = vc->vc_display_fg;
996	struct vc_data *svc = *default_mode;
997	struct fbcon_display *t, *p = &fb_display[vc->vc_num];
998	int logo = 1, new_rows, new_cols, rows, cols;
999	int ret;
1000
1001	if (WARN_ON(info_idx == -1))
1002	return;
1003
1004	if (con2fb_map[vc->vc_num] == -1)
1005	con2fb_map[vc->vc_num] = info_idx;
1006
1007	info = fbcon_info_from_console(console: vc->vc_num);
1008
1009	if (logo_shown < 0 && console_loglevel <= CONSOLE_LOGLEVEL_QUIET)
1010	logo_shown = FBCON_LOGO_DONTSHOW;
1011
1012	if (vc != svc || logo_shown == FBCON_LOGO_DONTSHOW ||
1013	(info->fix.type == FB_TYPE_TEXT))
1014	logo = 0;
1015
1016	if (var_to_display(disp: p, var: &info->var, info))
1017	return;
1018
1019	if (!info->fbcon_par)
1020	con2fb_acquire_newinfo(vc, info, unit: vc->vc_num);
1021
1022	/* If we are not the first console on this
1023	fb, copy the font from that console */
1024	t = &fb_display[fg_console];
1025	if (!p->fontdata) {
1026	if (t->fontdata) {
1027	struct vc_data *fvc = vc_cons[fg_console].d;
1028
1029	vc->vc_font.data = (void *)(p->fontdata =
1030	fvc->vc_font.data);
1031	vc->vc_font.width = fvc->vc_font.width;
1032	vc->vc_font.height = fvc->vc_font.height;
1033	vc->vc_font.charcount = fvc->vc_font.charcount;
1034	p->userfont = t->userfont;
1035
1036	if (p->userfont)
1037	REFCOUNT(p->fontdata)++;
1038	} else {
1039	const struct font_desc *font = NULL;
1040
1041	if (!fontname[0] || !(font = find_font(name: fontname)))
1042	font = get_default_font(xres: info->var.xres,
1043	yres: info->var.yres,
1044	font_w: info->pixmap.blit_x,
1045	font_h: info->pixmap.blit_y);
1046	vc->vc_font.width = font->width;
1047	vc->vc_font.height = font->height;
1048	vc->vc_font.data = (void *)(p->fontdata = font->data);
1049	vc->vc_font.charcount = font->charcount;
1050	}
1051	}
1052
1053	vc->vc_can_do_color = (fb_get_color_depth(var: &info->var, fix: &info->fix)!=1);
1054	vc->vc_complement_mask = vc->vc_can_do_color ? 0x7700 : 0x0800;
1055	if (vc->vc_font.charcount == 256) {
1056	vc->vc_hi_font_mask = 0;
1057	} else {
1058	vc->vc_hi_font_mask = 0x100;
1059	if (vc->vc_can_do_color)
1060	vc->vc_complement_mask <<= 1;
1061	}
1062
1063	if (!*svc->uni_pagedict_loc)
1064	con_set_default_unimap(vc: svc);
1065	if (!*vc->uni_pagedict_loc)
1066	con_copy_unimap(dst_vc: vc, src_vc: svc);
1067
1068	ops = info->fbcon_par;
1069	ops->cur_blink_jiffies = msecs_to_jiffies(m: vc->vc_cur_blink_ms);
1070
1071	p->con_rotate = initial_rotation;
1072	if (p->con_rotate == -1)
1073	p->con_rotate = info->fbcon_rotate_hint;
1074	if (p->con_rotate == -1)
1075	p->con_rotate = FB_ROTATE_UR;
1076
1077	set_blitting_type(vc, info);
1078
1079	cols = vc->vc_cols;
1080	rows = vc->vc_rows;
1081	new_cols = FBCON_SWAP(ops->rotate, info->var.xres, info->var.yres);
1082	new_rows = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres);
1083	new_cols /= vc->vc_font.width;
1084	new_rows /= vc->vc_font.height;
1085
1086	/*
1087	* We must always set the mode. The mode of the previous console
1088	* driver could be in the same resolution but we are using different
1089	* hardware so we have to initialize the hardware.
1090	*
1091	* We need to do it in fbcon_init() to prevent screen corruption.
1092	*/
1093	if (con_is_visible(vc) && vc->vc_mode == KD_TEXT) {
1094	if (info->fbops->fb_set_par && !ops->initialized) {
1095	ret = info->fbops->fb_set_par(info);
1096
1097	if (ret)
1098	printk(KERN_ERR "fbcon_init: detected "
1099	"unhandled fb_set_par error, "
1100	"error code %d\n", ret);
1101	}
1102
1103	ops->initialized = true;
1104	}
1105
1106	ops->graphics = 0;
1107
1108	#ifdef CONFIG_FRAMEBUFFER_CONSOLE_LEGACY_ACCELERATION
1109	if ((info->flags & FBINFO_HWACCEL_COPYAREA) &&
1110	!(info->flags & FBINFO_HWACCEL_DISABLED))
1111	p->scrollmode = SCROLL_MOVE;
1112	else /* default to something safe */
1113	p->scrollmode = SCROLL_REDRAW;
1114	#endif
1115
1116	/*
1117	* ++guenther: console.c:vc_allocate() relies on initializing
1118	* vc_{cols,rows}, but we must not set those if we are only
1119	* resizing the console.
1120	*/
1121	if (init) {
1122	vc->vc_cols = new_cols;
1123	vc->vc_rows = new_rows;
1124	} else
1125	vc_resize(vc, cols: new_cols, lines: new_rows);
1126
1127	if (logo)
1128	fbcon_prepare_logo(vc, info, cols, rows, new_cols, new_rows);
1129
1130	if (ops->rotate_font && ops->rotate_font(info, vc)) {
1131	ops->rotate = FB_ROTATE_UR;
1132	set_blitting_type(vc, info);
1133	}
1134
1135	ops->p = &fb_display[fg_console];
1136	}
1137
1138	static void fbcon_free_font(struct fbcon_display *p)
1139	{
1140	if (p->userfont && p->fontdata && (--REFCOUNT(p->fontdata) == 0))
1141	kfree(objp: p->fontdata - FONT_EXTRA_WORDS * sizeof(int));
1142	p->fontdata = NULL;
1143	p->userfont = 0;
1144	}
1145
1146	static void set_vc_hi_font(struct vc_data *vc, bool set);
1147
1148	static void fbcon_release_all(void)
1149	{
1150	struct fb_info *info;
1151	int i, j, mapped;
1152
1153	fbcon_for_each_registered_fb(i) {
1154	mapped = 0;
1155	info = fbcon_registered_fb[i];
1156
1157	for (j = first_fb_vc; j <= last_fb_vc; j++) {
1158	if (con2fb_map[j] == i) {
1159	mapped = 1;
1160	con2fb_map[j] = -1;
1161	}
1162	}
1163
1164	if (mapped)
1165	fbcon_release(info);
1166	}
1167	}
1168
1169	static void fbcon_deinit(struct vc_data *vc)
1170	{
1171	struct fbcon_display *p = &fb_display[vc->vc_num];
1172	struct fb_info *info;
1173	struct fbcon_ops *ops;
1174	int idx;
1175
1176	fbcon_free_font(p);
1177	idx = con2fb_map[vc->vc_num];
1178
1179	if (idx == -1)
1180	goto finished;
1181
1182	info = fbcon_registered_fb[idx];
1183
1184	if (!info)
1185	goto finished;
1186
1187	ops = info->fbcon_par;
1188
1189	if (!ops)
1190	goto finished;
1191
1192	if (con_is_visible(vc))
1193	fbcon_del_cursor_work(info);
1194
1195	ops->initialized = false;
1196	finished:
1197
1198	fbcon_free_font(p);
1199	vc->vc_font.data = NULL;
1200
1201	if (vc->vc_hi_font_mask && vc->vc_screenbuf)
1202	set_vc_hi_font(vc, set: false);
1203
1204	if (!con_is_bound(csw: &fb_con))
1205	fbcon_release_all();
1206
1207	if (vc->vc_num == logo_shown)
1208	logo_shown = FBCON_LOGO_CANSHOW;
1209
1210	return;
1211	}
1212
1213	/* ====================================================================== */
1214
1215	/* fbcon_XXX routines - interface used by the world
1216	*
1217	* This system is now divided into two levels because of complications
1218	* caused by hardware scrolling. Top level functions:
1219	*
1220	* fbcon_bmove(), fbcon_clear(), fbcon_putc(), fbcon_clear_margins()
1221	*
1222	* handles y values in range [0, scr_height-1] that correspond to real
1223	* screen positions. y_wrap shift means that first line of bitmap may be
1224	* anywhere on this display. These functions convert lineoffsets to
1225	* bitmap offsets and deal with the wrap-around case by splitting blits.
1226	*
1227	* fbcon_bmove_physical_8() -- These functions fast implementations
1228	* fbcon_clear_physical_8() -- of original fbcon_XXX fns.
1229	* fbcon_putc_physical_8() -- (font width != 8) may be added later
1230	*
1231	* WARNING:
1232	*
1233	* At the moment fbcon_putc() cannot blit across vertical wrap boundary
1234	* Implies should only really hardware scroll in rows. Only reason for
1235	* restriction is simplicity & efficiency at the moment.
1236	*/
1237
1238	static void fbcon_clear(struct vc_data *vc, int sy, int sx, int height,
1239	int width)
1240	{
1241	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
1242	struct fbcon_ops *ops = info->fbcon_par;
1243
1244	struct fbcon_display *p = &fb_display[vc->vc_num];
1245	u_int y_break;
1246
1247	if (fbcon_is_inactive(vc, info))
1248	return;
1249
1250	if (!height || !width)
1251	return;
1252
1253	if (sy < vc->vc_top && vc->vc_top == logo_lines) {
1254	vc->vc_top = 0;
1255	/*
1256	* If the font dimensions are not an integral of the display
1257	* dimensions then the ops->clear below won't end up clearing
1258	* the margins. Call clear_margins here in case the logo
1259	* bitmap stretched into the margin area.
1260	*/
1261	fbcon_clear_margins(vc, bottom_only: 0);
1262	}
1263
1264	/* Split blits that cross physical y_wrap boundary */
1265
1266	y_break = p->vrows - p->yscroll;
1267	if (sy < y_break && sy + height - 1 >= y_break) {
1268	u_int b = y_break - sy;
1269	ops->clear(vc, info, real_y(p, ypos: sy), sx, b, width);
1270	ops->clear(vc, info, real_y(p, ypos: sy + b), sx, height - b,
1271	width);
1272	} else
1273	ops->clear(vc, info, real_y(p, ypos: sy), sx, height, width);
1274	}
1275
1276	static void fbcon_putcs(struct vc_data *vc, const unsigned short *s,
1277	int count, int ypos, int xpos)
1278	{
1279	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
1280	struct fbcon_display *p = &fb_display[vc->vc_num];
1281	struct fbcon_ops *ops = info->fbcon_par;
1282
1283	if (!fbcon_is_inactive(vc, info))
1284	ops->putcs(vc, info, s, count, real_y(p, ypos), xpos,
1285	get_color(vc, info, scr_readw(s), is_fg: 1),
1286	get_color(vc, info, scr_readw(s), is_fg: 0));
1287	}
1288
1289	static void fbcon_putc(struct vc_data *vc, int c, int ypos, int xpos)
1290	{
1291	unsigned short chr;
1292
1293	scr_writew(c, &chr);
1294	fbcon_putcs(vc, s: &chr, count: 1, ypos, xpos);
1295	}
1296
1297	static void fbcon_clear_margins(struct vc_data *vc, int bottom_only)
1298	{
1299	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
1300	struct fbcon_ops *ops = info->fbcon_par;
1301
1302	if (!fbcon_is_inactive(vc, info))
1303	ops->clear_margins(vc, info, margin_color, bottom_only);
1304	}
1305
1306	static void fbcon_cursor(struct vc_data *vc, int mode)
1307	{
1308	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
1309	struct fbcon_ops *ops = info->fbcon_par;
1310	int c = scr_readw((u16 *) vc->vc_pos);
1311
1312	ops->cur_blink_jiffies = msecs_to_jiffies(m: vc->vc_cur_blink_ms);
1313
1314	if (fbcon_is_inactive(vc, info) || vc->vc_deccm != 1)
1315	return;
1316
1317	if (vc->vc_cursor_type & CUR_SW)
1318	fbcon_del_cursor_work(info);
1319	else
1320	fbcon_add_cursor_work(info);
1321
1322	ops->cursor_flash = (mode == CM_ERASE) ? 0 : 1;
1323
1324	if (!ops->cursor)
1325	return;
1326
1327	ops->cursor(vc, info, mode, get_color(vc, info, c, is_fg: 1),
1328	get_color(vc, info, c, is_fg: 0));
1329	}
1330
1331	static int scrollback_phys_max = 0;
1332	static int scrollback_max = 0;
1333	static int scrollback_current = 0;
1334
1335	static void fbcon_set_disp(struct fb_info *info, struct fb_var_screeninfo *var,
1336	int unit)
1337	{
1338	struct fbcon_display *p, *t;
1339	struct vc_data **default_mode, *vc;
1340	struct vc_data *svc;
1341	struct fbcon_ops *ops = info->fbcon_par;
1342	int rows, cols;
1343
1344	p = &fb_display[unit];
1345
1346	if (var_to_display(disp: p, var, info))
1347	return;
1348
1349	vc = vc_cons[unit].d;
1350
1351	if (!vc)
1352	return;
1353
1354	default_mode = vc->vc_display_fg;
1355	svc = *default_mode;
1356	t = &fb_display[svc->vc_num];
1357
1358	if (!vc->vc_font.data) {
1359	vc->vc_font.data = (void *)(p->fontdata = t->fontdata);
1360	vc->vc_font.width = (*default_mode)->vc_font.width;
1361	vc->vc_font.height = (*default_mode)->vc_font.height;
1362	vc->vc_font.charcount = (*default_mode)->vc_font.charcount;
1363	p->userfont = t->userfont;
1364	if (p->userfont)
1365	REFCOUNT(p->fontdata)++;
1366	}
1367
1368	var->activate = FB_ACTIVATE_NOW;
1369	info->var.activate = var->activate;
1370	var->yoffset = info->var.yoffset;
1371	var->xoffset = info->var.xoffset;
1372	fb_set_var(info, var);
1373	ops->var = info->var;
1374	vc->vc_can_do_color = (fb_get_color_depth(var: &info->var, fix: &info->fix)!=1);
1375	vc->vc_complement_mask = vc->vc_can_do_color ? 0x7700 : 0x0800;
1376	if (vc->vc_font.charcount == 256) {
1377	vc->vc_hi_font_mask = 0;
1378	} else {
1379	vc->vc_hi_font_mask = 0x100;
1380	if (vc->vc_can_do_color)
1381	vc->vc_complement_mask <<= 1;
1382	}
1383
1384	if (!*svc->uni_pagedict_loc)
1385	con_set_default_unimap(vc: svc);
1386	if (!*vc->uni_pagedict_loc)
1387	con_copy_unimap(dst_vc: vc, src_vc: svc);
1388
1389	cols = FBCON_SWAP(ops->rotate, info->var.xres, info->var.yres);
1390	rows = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres);
1391	cols /= vc->vc_font.width;
1392	rows /= vc->vc_font.height;
1393	vc_resize(vc, cols, lines: rows);
1394
1395	if (con_is_visible(vc)) {
1396	update_screen(vc);
1397	}
1398	}
1399
1400	static __inline__ void ywrap_up(struct vc_data *vc, int count)
1401	{
1402	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
1403	struct fbcon_ops *ops = info->fbcon_par;
1404	struct fbcon_display *p = &fb_display[vc->vc_num];
1405
1406	p->yscroll += count;
1407	if (p->yscroll >= p->vrows) /* Deal with wrap */
1408	p->yscroll -= p->vrows;
1409	ops->var.xoffset = 0;
1410	ops->var.yoffset = p->yscroll * vc->vc_font.height;
1411	ops->var.vmode |= FB_VMODE_YWRAP;
1412	ops->update_start(info);
1413	scrollback_max += count;
1414	if (scrollback_max > scrollback_phys_max)
1415	scrollback_max = scrollback_phys_max;
1416	scrollback_current = 0;
1417	}
1418
1419	static __inline__ void ywrap_down(struct vc_data *vc, int count)
1420	{
1421	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
1422	struct fbcon_ops *ops = info->fbcon_par;
1423	struct fbcon_display *p = &fb_display[vc->vc_num];
1424
1425	p->yscroll -= count;
1426	if (p->yscroll < 0) /* Deal with wrap */
1427	p->yscroll += p->vrows;
1428	ops->var.xoffset = 0;
1429	ops->var.yoffset = p->yscroll * vc->vc_font.height;
1430	ops->var.vmode |= FB_VMODE_YWRAP;
1431	ops->update_start(info);
1432	scrollback_max -= count;
1433	if (scrollback_max < 0)
1434	scrollback_max = 0;
1435	scrollback_current = 0;
1436	}
1437
1438	static __inline__ void ypan_up(struct vc_data *vc, int count)
1439	{
1440	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
1441	struct fbcon_display *p = &fb_display[vc->vc_num];
1442	struct fbcon_ops *ops = info->fbcon_par;
1443
1444	p->yscroll += count;
1445	if (p->yscroll > p->vrows - vc->vc_rows) {
1446	ops->bmove(vc, info, p->vrows - vc->vc_rows,
1447	0, 0, 0, vc->vc_rows, vc->vc_cols);
1448	p->yscroll -= p->vrows - vc->vc_rows;
1449	}
1450
1451	ops->var.xoffset = 0;
1452	ops->var.yoffset = p->yscroll * vc->vc_font.height;
1453	ops->var.vmode &= ~FB_VMODE_YWRAP;
1454	ops->update_start(info);
1455	fbcon_clear_margins(vc, bottom_only: 1);
1456	scrollback_max += count;
1457	if (scrollback_max > scrollback_phys_max)
1458	scrollback_max = scrollback_phys_max;
1459	scrollback_current = 0;
1460	}
1461
1462	static __inline__ void ypan_up_redraw(struct vc_data *vc, int t, int count)
1463	{
1464	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
1465	struct fbcon_ops *ops = info->fbcon_par;
1466	struct fbcon_display *p = &fb_display[vc->vc_num];
1467
1468	p->yscroll += count;
1469
1470	if (p->yscroll > p->vrows - vc->vc_rows) {
1471	p->yscroll -= p->vrows - vc->vc_rows;
1472	fbcon_redraw_move(vc, p, line: t + count, count: vc->vc_rows - count, dy: t);
1473	}
1474
1475	ops->var.xoffset = 0;
1476	ops->var.yoffset = p->yscroll * vc->vc_font.height;
1477	ops->var.vmode &= ~FB_VMODE_YWRAP;
1478	ops->update_start(info);
1479	fbcon_clear_margins(vc, bottom_only: 1);
1480	scrollback_max += count;
1481	if (scrollback_max > scrollback_phys_max)
1482	scrollback_max = scrollback_phys_max;
1483	scrollback_current = 0;
1484	}
1485
1486	static __inline__ void ypan_down(struct vc_data *vc, int count)
1487	{
1488	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
1489	struct fbcon_display *p = &fb_display[vc->vc_num];
1490	struct fbcon_ops *ops = info->fbcon_par;
1491
1492	p->yscroll -= count;
1493	if (p->yscroll < 0) {
1494	ops->bmove(vc, info, 0, 0, p->vrows - vc->vc_rows,
1495	0, vc->vc_rows, vc->vc_cols);
1496	p->yscroll += p->vrows - vc->vc_rows;
1497	}
1498
1499	ops->var.xoffset = 0;
1500	ops->var.yoffset = p->yscroll * vc->vc_font.height;
1501	ops->var.vmode &= ~FB_VMODE_YWRAP;
1502	ops->update_start(info);
1503	fbcon_clear_margins(vc, bottom_only: 1);
1504	scrollback_max -= count;
1505	if (scrollback_max < 0)
1506	scrollback_max = 0;
1507	scrollback_current = 0;
1508	}
1509
1510	static __inline__ void ypan_down_redraw(struct vc_data *vc, int t, int count)
1511	{
1512	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
1513	struct fbcon_ops *ops = info->fbcon_par;
1514	struct fbcon_display *p = &fb_display[vc->vc_num];
1515
1516	p->yscroll -= count;
1517
1518	if (p->yscroll < 0) {
1519	p->yscroll += p->vrows - vc->vc_rows;
1520	fbcon_redraw_move(vc, p, line: t, count: vc->vc_rows - count, dy: t + count);
1521	}
1522
1523	ops->var.xoffset = 0;
1524	ops->var.yoffset = p->yscroll * vc->vc_font.height;
1525	ops->var.vmode &= ~FB_VMODE_YWRAP;
1526	ops->update_start(info);
1527	fbcon_clear_margins(vc, bottom_only: 1);
1528	scrollback_max -= count;
1529	if (scrollback_max < 0)
1530	scrollback_max = 0;
1531	scrollback_current = 0;
1532	}
1533
1534	static void fbcon_redraw_move(struct vc_data *vc, struct fbcon_display *p,
1535	int line, int count, int dy)
1536	{
1537	unsigned short *s = (unsigned short *)
1538	(vc->vc_origin + vc->vc_size_row * line);
1539
1540	while (count--) {
1541	unsigned short *start = s;
1542	unsigned short *le = advance_row(s, 1);
1543	unsigned short c;
1544	int x = 0;
1545	unsigned short attr = 1;
1546
1547	do {
1548	c = scr_readw(s);
1549	if (attr != (c & 0xff00)) {
1550	attr = c & 0xff00;
1551	if (s > start) {
1552	fbcon_putcs(vc, s: start, count: s - start,
1553	ypos: dy, xpos: x);
1554	x += s - start;
1555	start = s;
1556	}
1557	}
1558	console_conditional_schedule();
1559	s++;
1560	} while (s < le);
1561	if (s > start)
1562	fbcon_putcs(vc, s: start, count: s - start, ypos: dy, xpos: x);
1563	console_conditional_schedule();
1564	dy++;
1565	}
1566	}
1567
1568	static void fbcon_redraw_blit(struct vc_data *vc, struct fb_info *info,
1569	struct fbcon_display *p, int line, int count, int ycount)
1570	{
1571	int offset = ycount * vc->vc_cols;
1572	unsigned short *d = (unsigned short *)
1573	(vc->vc_origin + vc->vc_size_row * line);
1574	unsigned short *s = d + offset;
1575	struct fbcon_ops *ops = info->fbcon_par;
1576
1577	while (count--) {
1578	unsigned short *start = s;
1579	unsigned short *le = advance_row(s, 1);
1580	unsigned short c;
1581	int x = 0;
1582
1583	do {
1584	c = scr_readw(s);
1585
1586	if (c == scr_readw(d)) {
1587	if (s > start) {
1588	ops->bmove(vc, info, line + ycount, x,
1589	line, x, 1, s-start);
1590	x += s - start + 1;
1591	start = s + 1;
1592	} else {
1593	x++;
1594	start++;
1595	}
1596	}
1597
1598	scr_writew(c, d);
1599	console_conditional_schedule();
1600	s++;
1601	d++;
1602	} while (s < le);
1603	if (s > start)
1604	ops->bmove(vc, info, line + ycount, x, line, x, 1,
1605	s-start);
1606	console_conditional_schedule();
1607	if (ycount > 0)
1608	line++;
1609	else {
1610	line--;
1611	/* NOTE: We subtract two lines from these pointers */
1612	s -= vc->vc_size_row;
1613	d -= vc->vc_size_row;
1614	}
1615	}
1616	}
1617
1618	static void fbcon_redraw(struct vc_data *vc, int line, int count, int offset)
1619	{
1620	unsigned short *d = (unsigned short *)
1621	(vc->vc_origin + vc->vc_size_row * line);
1622	unsigned short *s = d + offset;
1623
1624	while (count--) {
1625	unsigned short *start = s;
1626	unsigned short *le = advance_row(s, 1);
1627	unsigned short c;
1628	int x = 0;
1629	unsigned short attr = 1;
1630
1631	do {
1632	c = scr_readw(s);
1633	if (attr != (c & 0xff00)) {
1634	attr = c & 0xff00;
1635	if (s > start) {
1636	fbcon_putcs(vc, s: start, count: s - start,
1637	ypos: line, xpos: x);
1638	x += s - start;
1639	start = s;
1640	}
1641	}
1642	if (c == scr_readw(d)) {
1643	if (s > start) {
1644	fbcon_putcs(vc, s: start, count: s - start,
1645	ypos: line, xpos: x);
1646	x += s - start + 1;
1647	start = s + 1;
1648	} else {
1649	x++;
1650	start++;
1651	}
1652	}
1653	scr_writew(c, d);
1654	console_conditional_schedule();
1655	s++;
1656	d++;
1657	} while (s < le);
1658	if (s > start)
1659	fbcon_putcs(vc, s: start, count: s - start, ypos: line, xpos: x);
1660	console_conditional_schedule();
1661	if (offset > 0)
1662	line++;
1663	else {
1664	line--;
1665	/* NOTE: We subtract two lines from these pointers */
1666	s -= vc->vc_size_row;
1667	d -= vc->vc_size_row;
1668	}
1669	}
1670	}
1671
1672	static void fbcon_bmove_rec(struct vc_data *vc, struct fbcon_display *p, int sy, int sx,
1673	int dy, int dx, int height, int width, u_int y_break)
1674	{
1675	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
1676	struct fbcon_ops *ops = info->fbcon_par;
1677	u_int b;
1678
1679	if (sy < y_break && sy + height > y_break) {
1680	b = y_break - sy;
1681	if (dy < sy) { /* Avoid trashing self */
1682	fbcon_bmove_rec(vc, p, sy, sx, dy, dx, height: b, width,
1683	y_break);
1684	fbcon_bmove_rec(vc, p, sy: sy + b, sx, dy: dy + b, dx,
1685	height: height - b, width, y_break);
1686	} else {
1687	fbcon_bmove_rec(vc, p, sy: sy + b, sx, dy: dy + b, dx,
1688	height: height - b, width, y_break);
1689	fbcon_bmove_rec(vc, p, sy, sx, dy, dx, height: b, width,
1690	y_break);
1691	}
1692	return;
1693	}
1694
1695	if (dy < y_break && dy + height > y_break) {
1696	b = y_break - dy;
1697	if (dy < sy) { /* Avoid trashing self */
1698	fbcon_bmove_rec(vc, p, sy, sx, dy, dx, height: b, width,
1699	y_break);
1700	fbcon_bmove_rec(vc, p, sy: sy + b, sx, dy: dy + b, dx,
1701	height: height - b, width, y_break);
1702	} else {
1703	fbcon_bmove_rec(vc, p, sy: sy + b, sx, dy: dy + b, dx,
1704	height: height - b, width, y_break);
1705	fbcon_bmove_rec(vc, p, sy, sx, dy, dx, height: b, width,
1706	y_break);
1707	}
1708	return;
1709	}
1710	ops->bmove(vc, info, real_y(p, ypos: sy), sx, real_y(p, ypos: dy), dx,
1711	height, width);
1712	}
1713
1714	static void fbcon_bmove(struct vc_data *vc, int sy, int sx, int dy, int dx,
1715	int height, int width)
1716	{
1717	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
1718	struct fbcon_display *p = &fb_display[vc->vc_num];
1719
1720	if (fbcon_is_inactive(vc, info))
1721	return;
1722
1723	if (!width || !height)
1724	return;
1725
1726	/* Split blits that cross physical y_wrap case.
1727	* Pathological case involves 4 blits, better to use recursive
1728	* code rather than unrolled case
1729	*
1730	* Recursive invocations don't need to erase the cursor over and
1731	* over again, so we use fbcon_bmove_rec()
1732	*/
1733	fbcon_bmove_rec(vc, p, sy, sx, dy, dx, height, width,
1734	y_break: p->vrows - p->yscroll);
1735	}
1736
1737	static bool fbcon_scroll(struct vc_data *vc, unsigned int t, unsigned int b,
1738	enum con_scroll dir, unsigned int count)
1739	{
1740	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
1741	struct fbcon_display *p = &fb_display[vc->vc_num];
1742	int scroll_partial = info->flags & FBINFO_PARTIAL_PAN_OK;
1743
1744	if (fbcon_is_inactive(vc, info))
1745	return true;
1746
1747	fbcon_cursor(vc, CM_ERASE);
1748
1749	/*
1750	* ++Geert: Only use ywrap/ypan if the console is in text mode
1751	* ++Andrew: Only use ypan on hardware text mode when scrolling the
1752	* whole screen (prevents flicker).
1753	*/
1754
1755	switch (dir) {
1756	case SM_UP:
1757	if (count > vc->vc_rows) /* Maximum realistic size */
1758	count = vc->vc_rows;
1759	switch (fb_scrollmode(fb: p)) {
1760	case SCROLL_MOVE:
1761	fbcon_redraw_blit(vc, info, p, line: t, count: b - t - count,
1762	ycount: count);
1763	fbcon_clear(vc, sy: b - count, sx: 0, height: count, width: vc->vc_cols);
1764	scr_memsetw(s: (unsigned short *) (vc->vc_origin +
1765	vc->vc_size_row *
1766	(b - count)),
1767	c: vc->vc_video_erase_char,
1768	count: vc->vc_size_row * count);
1769	return true;
1770
1771	case SCROLL_WRAP_MOVE:
1772	if (b - t - count > 3 * vc->vc_rows >> 2) {
1773	if (t > 0)
1774	fbcon_bmove(vc, sy: 0, sx: 0, dy: count, dx: 0, height: t,
1775	width: vc->vc_cols);
1776	ywrap_up(vc, count);
1777	if (vc->vc_rows - b > 0)
1778	fbcon_bmove(vc, sy: b - count, sx: 0, dy: b, dx: 0,
1779	height: vc->vc_rows - b,
1780	width: vc->vc_cols);
1781	} else if (info->flags & FBINFO_READS_FAST)
1782	fbcon_bmove(vc, sy: t + count, sx: 0, dy: t, dx: 0,
1783	height: b - t - count, width: vc->vc_cols);
1784	else
1785	goto redraw_up;
1786	fbcon_clear(vc, sy: b - count, sx: 0, height: count, width: vc->vc_cols);
1787	break;
1788
1789	case SCROLL_PAN_REDRAW:
1790	if ((p->yscroll + count <=
1791	2 * (p->vrows - vc->vc_rows))
1792	&& ((!scroll_partial && (b - t == vc->vc_rows))
1793	|| (scroll_partial
1794	&& (b - t - count >
1795	3 * vc->vc_rows >> 2)))) {
1796	if (t > 0)
1797	fbcon_redraw_move(vc, p, line: 0, count: t, dy: count);
1798	ypan_up_redraw(vc, t, count);
1799	if (vc->vc_rows - b > 0)
1800	fbcon_redraw_move(vc, p, line: b,
1801	count: vc->vc_rows - b, dy: b);
1802	} else
1803	fbcon_redraw_move(vc, p, line: t + count, count: b - t - count, dy: t);
1804	fbcon_clear(vc, sy: b - count, sx: 0, height: count, width: vc->vc_cols);
1805	break;
1806
1807	case SCROLL_PAN_MOVE:
1808	if ((p->yscroll + count <=
1809	2 * (p->vrows - vc->vc_rows))
1810	&& ((!scroll_partial && (b - t == vc->vc_rows))
1811	|| (scroll_partial
1812	&& (b - t - count >
1813	3 * vc->vc_rows >> 2)))) {
1814	if (t > 0)
1815	fbcon_bmove(vc, sy: 0, sx: 0, dy: count, dx: 0, height: t,
1816	width: vc->vc_cols);
1817	ypan_up(vc, count);
1818	if (vc->vc_rows - b > 0)
1819	fbcon_bmove(vc, sy: b - count, sx: 0, dy: b, dx: 0,
1820	height: vc->vc_rows - b,
1821	width: vc->vc_cols);
1822	} else if (info->flags & FBINFO_READS_FAST)
1823	fbcon_bmove(vc, sy: t + count, sx: 0, dy: t, dx: 0,
1824	height: b - t - count, width: vc->vc_cols);
1825	else
1826	goto redraw_up;
1827	fbcon_clear(vc, sy: b - count, sx: 0, height: count, width: vc->vc_cols);
1828	break;
1829
1830	case SCROLL_REDRAW:
1831	redraw_up:
1832	fbcon_redraw(vc, line: t, count: b - t - count,
1833	offset: count * vc->vc_cols);
1834	fbcon_clear(vc, sy: b - count, sx: 0, height: count, width: vc->vc_cols);
1835	scr_memsetw(s: (unsigned short *) (vc->vc_origin +
1836	vc->vc_size_row *
1837	(b - count)),
1838	c: vc->vc_video_erase_char,
1839	count: vc->vc_size_row * count);
1840	return true;
1841	}
1842	break;
1843
1844	case SM_DOWN:
1845	if (count > vc->vc_rows) /* Maximum realistic size */
1846	count = vc->vc_rows;
1847	switch (fb_scrollmode(fb: p)) {
1848	case SCROLL_MOVE:
1849	fbcon_redraw_blit(vc, info, p, line: b - 1, count: b - t - count,
1850	ycount: -count);
1851	fbcon_clear(vc, sy: t, sx: 0, height: count, width: vc->vc_cols);
1852	scr_memsetw(s: (unsigned short *) (vc->vc_origin +
1853	vc->vc_size_row *
1854	t),
1855	c: vc->vc_video_erase_char,
1856	count: vc->vc_size_row * count);
1857	return true;
1858
1859	case SCROLL_WRAP_MOVE:
1860	if (b - t - count > 3 * vc->vc_rows >> 2) {
1861	if (vc->vc_rows - b > 0)
1862	fbcon_bmove(vc, sy: b, sx: 0, dy: b - count, dx: 0,
1863	height: vc->vc_rows - b,
1864	width: vc->vc_cols);
1865	ywrap_down(vc, count);
1866	if (t > 0)
1867	fbcon_bmove(vc, sy: count, sx: 0, dy: 0, dx: 0, height: t,
1868	width: vc->vc_cols);
1869	} else if (info->flags & FBINFO_READS_FAST)
1870	fbcon_bmove(vc, sy: t, sx: 0, dy: t + count, dx: 0,
1871	height: b - t - count, width: vc->vc_cols);
1872	else
1873	goto redraw_down;
1874	fbcon_clear(vc, sy: t, sx: 0, height: count, width: vc->vc_cols);
1875	break;
1876
1877	case SCROLL_PAN_MOVE:
1878	if ((count - p->yscroll <= p->vrows - vc->vc_rows)
1879	&& ((!scroll_partial && (b - t == vc->vc_rows))
1880	|| (scroll_partial
1881	&& (b - t - count >
1882	3 * vc->vc_rows >> 2)))) {
1883	if (vc->vc_rows - b > 0)
1884	fbcon_bmove(vc, sy: b, sx: 0, dy: b - count, dx: 0,
1885	height: vc->vc_rows - b,
1886	width: vc->vc_cols);
1887	ypan_down(vc, count);
1888	if (t > 0)
1889	fbcon_bmove(vc, sy: count, sx: 0, dy: 0, dx: 0, height: t,
1890	width: vc->vc_cols);
1891	} else if (info->flags & FBINFO_READS_FAST)
1892	fbcon_bmove(vc, sy: t, sx: 0, dy: t + count, dx: 0,
1893	height: b - t - count, width: vc->vc_cols);
1894	else
1895	goto redraw_down;
1896	fbcon_clear(vc, sy: t, sx: 0, height: count, width: vc->vc_cols);
1897	break;
1898
1899	case SCROLL_PAN_REDRAW:
1900	if ((count - p->yscroll <= p->vrows - vc->vc_rows)
1901	&& ((!scroll_partial && (b - t == vc->vc_rows))
1902	|| (scroll_partial
1903	&& (b - t - count >
1904	3 * vc->vc_rows >> 2)))) {
1905	if (vc->vc_rows - b > 0)
1906	fbcon_redraw_move(vc, p, line: b, count: vc->vc_rows - b,
1907	dy: b - count);
1908	ypan_down_redraw(vc, t, count);
1909	if (t > 0)
1910	fbcon_redraw_move(vc, p, line: count, count: t, dy: 0);
1911	} else
1912	fbcon_redraw_move(vc, p, line: t, count: b - t - count, dy: t + count);
1913	fbcon_clear(vc, sy: t, sx: 0, height: count, width: vc->vc_cols);
1914	break;
1915
1916	case SCROLL_REDRAW:
1917	redraw_down:
1918	fbcon_redraw(vc, line: b - 1, count: b - t - count,
1919	offset: -count * vc->vc_cols);
1920	fbcon_clear(vc, sy: t, sx: 0, height: count, width: vc->vc_cols);
1921	scr_memsetw(s: (unsigned short *) (vc->vc_origin +
1922	vc->vc_size_row *
1923	t),
1924	c: vc->vc_video_erase_char,
1925	count: vc->vc_size_row * count);
1926	return true;
1927	}
1928	}
1929	return false;
1930	}
1931
1932
1933	static void updatescrollmode_accel(struct fbcon_display *p,
1934	struct fb_info *info,
1935	struct vc_data *vc)
1936	{
1937	#ifdef CONFIG_FRAMEBUFFER_CONSOLE_LEGACY_ACCELERATION
1938	struct fbcon_ops *ops = info->fbcon_par;
1939	int cap = info->flags;
1940	u16 t = 0;
1941	int ypan = FBCON_SWAP(ops->rotate, info->fix.ypanstep,
1942	info->fix.xpanstep);
1943	int ywrap = FBCON_SWAP(ops->rotate, info->fix.ywrapstep, t);
1944	int yres = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres);
1945	int vyres = FBCON_SWAP(ops->rotate, info->var.yres_virtual,
1946	info->var.xres_virtual);
1947	int good_pan = (cap & FBINFO_HWACCEL_YPAN) &&
1948	divides(ypan, vc->vc_font.height) && vyres > yres;
1949	int good_wrap = (cap & FBINFO_HWACCEL_YWRAP) &&
1950	divides(ywrap, vc->vc_font.height) &&
1951	divides(vc->vc_font.height, vyres) &&
1952	divides(vc->vc_font.height, yres);
1953	int reading_fast = cap & FBINFO_READS_FAST;
1954	int fast_copyarea = (cap & FBINFO_HWACCEL_COPYAREA) &&
1955	!(cap & FBINFO_HWACCEL_DISABLED);
1956	int fast_imageblit = (cap & FBINFO_HWACCEL_IMAGEBLIT) &&
1957	!(cap & FBINFO_HWACCEL_DISABLED);
1958
1959	if (good_wrap || good_pan) {
1960	if (reading_fast || fast_copyarea)
1961	p->scrollmode = good_wrap ?
1962	SCROLL_WRAP_MOVE : SCROLL_PAN_MOVE;
1963	else
1964	p->scrollmode = good_wrap ? SCROLL_REDRAW :
1965	SCROLL_PAN_REDRAW;
1966	} else {
1967	if (reading_fast || (fast_copyarea && !fast_imageblit))
1968	p->scrollmode = SCROLL_MOVE;
1969	else
1970	p->scrollmode = SCROLL_REDRAW;
1971	}
1972	#endif
1973	}
1974
1975	static void updatescrollmode(struct fbcon_display *p,
1976	struct fb_info *info,
1977	struct vc_data *vc)
1978	{
1979	struct fbcon_ops *ops = info->fbcon_par;
1980	int fh = vc->vc_font.height;
1981	int yres = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres);
1982	int vyres = FBCON_SWAP(ops->rotate, info->var.yres_virtual,
1983	info->var.xres_virtual);
1984
1985	p->vrows = vyres/fh;
1986	if (yres > (fh * (vc->vc_rows + 1)))
1987	p->vrows -= (yres - (fh * vc->vc_rows)) / fh;
1988	if ((yres % fh) && (vyres % fh < yres % fh))
1989	p->vrows--;
1990
1991	/* update scrollmode in case hardware acceleration is used */
1992	updatescrollmode_accel(p, info, vc);
1993	}
1994
1995	#define PITCH(w) (((w) + 7) >> 3)
1996	#define CALC_FONTSZ(h, p, c) ((h) * (p) * (c)) /* size = height * pitch * charcount */
1997
1998	static int fbcon_resize(struct vc_data *vc, unsigned int width,
1999	unsigned int height, unsigned int user)
2000	{
2001	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
2002	struct fbcon_ops *ops = info->fbcon_par;
2003	struct fbcon_display *p = &fb_display[vc->vc_num];
2004	struct fb_var_screeninfo var = info->var;
2005	int x_diff, y_diff, virt_w, virt_h, virt_fw, virt_fh;
2006
2007	if (p->userfont && FNTSIZE(vc->vc_font.data)) {
2008	int size;
2009	int pitch = PITCH(vc->vc_font.width);
2010
2011	/*
2012	* If user font, ensure that a possible change to user font
2013	* height or width will not allow a font data out-of-bounds access.
2014	* NOTE: must use original charcount in calculation as font
2015	* charcount can change and cannot be used to determine the
2016	* font data allocated size.
2017	*/
2018	if (pitch <= 0)
2019	return -EINVAL;
2020	size = CALC_FONTSZ(vc->vc_font.height, pitch, vc->vc_font.charcount);
2021	if (size > FNTSIZE(vc->vc_font.data))
2022	return -EINVAL;
2023	}
2024
2025	virt_w = FBCON_SWAP(ops->rotate, width, height);
2026	virt_h = FBCON_SWAP(ops->rotate, height, width);
2027	virt_fw = FBCON_SWAP(ops->rotate, vc->vc_font.width,
2028	vc->vc_font.height);
2029	virt_fh = FBCON_SWAP(ops->rotate, vc->vc_font.height,
2030	vc->vc_font.width);
2031	var.xres = virt_w * virt_fw;
2032	var.yres = virt_h * virt_fh;
2033	x_diff = info->var.xres - var.xres;
2034	y_diff = info->var.yres - var.yres;
2035	if (x_diff < 0 || x_diff > virt_fw ||
2036	y_diff < 0 || y_diff > virt_fh) {
2037	const struct fb_videomode *mode;
2038
2039	pr_debug("attempting resize %ix%i\n", var.xres, var.yres);
2040	mode = fb_find_best_mode(var: &var, head: &info->modelist);
2041	if (mode == NULL)
2042	return -EINVAL;
2043	display_to_var(var: &var, disp: p);
2044	fb_videomode_to_var(var: &var, mode);
2045
2046	if (virt_w > var.xres/virt_fw || virt_h > var.yres/virt_fh)
2047	return -EINVAL;
2048
2049	pr_debug("resize now %ix%i\n", var.xres, var.yres);
2050	if (con_is_visible(vc) && vc->vc_mode == KD_TEXT) {
2051	var.activate = FB_ACTIVATE_NOW |
2052	FB_ACTIVATE_FORCE;
2053	fb_set_var(info, var: &var);
2054	}
2055	var_to_display(disp: p, var: &info->var, info);
2056	ops->var = info->var;
2057	}
2058	updatescrollmode(p, info, vc);
2059	return 0;
2060	}
2061
2062	static int fbcon_switch(struct vc_data *vc)
2063	{
2064	struct fb_info *info, *old_info = NULL;
2065	struct fbcon_ops *ops;
2066	struct fbcon_display *p = &fb_display[vc->vc_num];
2067	struct fb_var_screeninfo var;
2068	int i, ret, prev_console;
2069
2070	info = fbcon_info_from_console(console: vc->vc_num);
2071	ops = info->fbcon_par;
2072
2073	if (logo_shown >= 0) {
2074	struct vc_data *conp2 = vc_cons[logo_shown].d;
2075
2076	if (conp2->vc_top == logo_lines
2077	&& conp2->vc_bottom == conp2->vc_rows)
2078	conp2->vc_top = 0;
2079	logo_shown = FBCON_LOGO_CANSHOW;
2080	}
2081
2082	prev_console = ops->currcon;
2083	if (prev_console != -1)
2084	old_info = fbcon_info_from_console(console: prev_console);
2085	/*
2086	* FIXME: If we have multiple fbdev's loaded, we need to
2087	* update all info->currcon. Perhaps, we can place this
2088	* in a centralized structure, but this might break some
2089	* drivers.
2090	*
2091	* info->currcon = vc->vc_num;
2092	*/
2093	fbcon_for_each_registered_fb(i) {
2094	if (fbcon_registered_fb[i]->fbcon_par) {
2095	struct fbcon_ops *o = fbcon_registered_fb[i]->fbcon_par;
2096
2097	o->currcon = vc->vc_num;
2098	}
2099	}
2100	memset(&var, 0, sizeof(struct fb_var_screeninfo));
2101	display_to_var(var: &var, disp: p);
2102	var.activate = FB_ACTIVATE_NOW;
2103
2104	/*
2105	* make sure we don't unnecessarily trip the memcmp()
2106	* in fb_set_var()
2107	*/
2108	info->var.activate = var.activate;
2109	var.vmode |= info->var.vmode & ~FB_VMODE_MASK;
2110	fb_set_var(info, var: &var);
2111	ops->var = info->var;
2112
2113	if (old_info != NULL && (old_info != info ||
2114	info->flags & FBINFO_MISC_ALWAYS_SETPAR)) {
2115	if (info->fbops->fb_set_par) {
2116	ret = info->fbops->fb_set_par(info);
2117
2118	if (ret)
2119	printk(KERN_ERR "fbcon_switch: detected "
2120	"unhandled fb_set_par error, "
2121	"error code %d\n", ret);
2122	}
2123
2124	if (old_info != info)
2125	fbcon_del_cursor_work(info: old_info);
2126	}
2127
2128	if (fbcon_is_inactive(vc, info) ||
2129	ops->blank_state != FB_BLANK_UNBLANK)
2130	fbcon_del_cursor_work(info);
2131	else
2132	fbcon_add_cursor_work(info);
2133
2134	set_blitting_type(vc, info);
2135	ops->cursor_reset = 1;
2136
2137	if (ops->rotate_font && ops->rotate_font(info, vc)) {
2138	ops->rotate = FB_ROTATE_UR;
2139	set_blitting_type(vc, info);
2140	}
2141
2142	vc->vc_can_do_color = (fb_get_color_depth(var: &info->var, fix: &info->fix)!=1);
2143	vc->vc_complement_mask = vc->vc_can_do_color ? 0x7700 : 0x0800;
2144
2145	if (vc->vc_font.charcount > 256)
2146	vc->vc_complement_mask <<= 1;
2147
2148	updatescrollmode(p, info, vc);
2149
2150	switch (fb_scrollmode(fb: p)) {
2151	case SCROLL_WRAP_MOVE:
2152	scrollback_phys_max = p->vrows - vc->vc_rows;
2153	break;
2154	case SCROLL_PAN_MOVE:
2155	case SCROLL_PAN_REDRAW:
2156	scrollback_phys_max = p->vrows - 2 * vc->vc_rows;
2157	if (scrollback_phys_max < 0)
2158	scrollback_phys_max = 0;
2159	break;
2160	default:
2161	scrollback_phys_max = 0;
2162	break;
2163	}
2164
2165	scrollback_max = 0;
2166	scrollback_current = 0;
2167
2168	if (!fbcon_is_inactive(vc, info)) {
2169	ops->var.xoffset = ops->var.yoffset = p->yscroll = 0;
2170	ops->update_start(info);
2171	}
2172
2173	fbcon_set_palette(vc, table: color_table);
2174	fbcon_clear_margins(vc, bottom_only: 0);
2175
2176	if (logo_shown == FBCON_LOGO_DRAW) {
2177
2178	logo_shown = fg_console;
2179	fb_show_logo(fb_info: info, rotate: ops->rotate);
2180	update_region(vc,
2181	start: vc->vc_origin + vc->vc_size_row * vc->vc_top,
2182	count: vc->vc_size_row * (vc->vc_bottom -
2183	vc->vc_top) / 2);
2184	return 0;
2185	}
2186	return 1;
2187	}
2188
2189	static void fbcon_generic_blank(struct vc_data *vc, struct fb_info *info,
2190	int blank)
2191	{
2192	if (blank) {
2193	unsigned short charmask = vc->vc_hi_font_mask ?
2194	0x1ff : 0xff;
2195	unsigned short oldc;
2196
2197	oldc = vc->vc_video_erase_char;
2198	vc->vc_video_erase_char &= charmask;
2199	fbcon_clear(vc, sy: 0, sx: 0, height: vc->vc_rows, width: vc->vc_cols);
2200	vc->vc_video_erase_char = oldc;
2201	}
2202	}
2203
2204	static int fbcon_blank(struct vc_data *vc, int blank, int mode_switch)
2205	{
2206	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
2207	struct fbcon_ops *ops = info->fbcon_par;
2208
2209	if (mode_switch) {
2210	struct fb_var_screeninfo var = info->var;
2211
2212	ops->graphics = 1;
2213
2214	if (!blank) {
2215	var.activate = FB_ACTIVATE_NOW | FB_ACTIVATE_FORCE |
2216	FB_ACTIVATE_KD_TEXT;
2217	fb_set_var(info, var: &var);
2218	ops->graphics = 0;
2219	ops->var = info->var;
2220	}
2221	}
2222
2223	if (!fbcon_is_inactive(vc, info)) {
2224	if (ops->blank_state != blank) {
2225	ops->blank_state = blank;
2226	fbcon_cursor(vc, mode: blank ? CM_ERASE : CM_DRAW);
2227	ops->cursor_flash = (!blank);
2228
2229	if (fb_blank(info, blank))
2230	fbcon_generic_blank(vc, info, blank);
2231	}
2232
2233	if (!blank)
2234	update_screen(vc);
2235	}
2236
2237	if (mode_switch || fbcon_is_inactive(vc, info) ||
2238	ops->blank_state != FB_BLANK_UNBLANK)
2239	fbcon_del_cursor_work(info);
2240	else
2241	fbcon_add_cursor_work(info);
2242
2243	return 0;
2244	}
2245
2246	static int fbcon_debug_enter(struct vc_data *vc)
2247	{
2248	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
2249	struct fbcon_ops *ops = info->fbcon_par;
2250
2251	ops->save_graphics = ops->graphics;
2252	ops->graphics = 0;
2253	if (info->fbops->fb_debug_enter)
2254	info->fbops->fb_debug_enter(info);
2255	fbcon_set_palette(vc, table: color_table);
2256	return 0;
2257	}
2258
2259	static int fbcon_debug_leave(struct vc_data *vc)
2260	{
2261	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
2262	struct fbcon_ops *ops = info->fbcon_par;
2263
2264	ops->graphics = ops->save_graphics;
2265	if (info->fbops->fb_debug_leave)
2266	info->fbops->fb_debug_leave(info);
2267	return 0;
2268	}
2269
2270	static int fbcon_get_font(struct vc_data *vc, struct console_font *font, unsigned int vpitch)
2271	{
2272	u8 *fontdata = vc->vc_font.data;
2273	u8 *data = font->data;
2274	int i, j;
2275
2276	font->width = vc->vc_font.width;
2277	font->height = vc->vc_font.height;
2278	if (font->height > vpitch)
2279	return -ENOSPC;
2280	font->charcount = vc->vc_hi_font_mask ? 512 : 256;
2281	if (!font->data)
2282	return 0;
2283
2284	if (font->width <= 8) {
2285	j = vc->vc_font.height;
2286	if (font->charcount * j > FNTSIZE(fontdata))
2287	return -EINVAL;
2288
2289	for (i = 0; i < font->charcount; i++) {
2290	memcpy(data, fontdata, j);
2291	memset(data + j, 0, vpitch - j);
2292	data += vpitch;
2293	fontdata += j;
2294	}
2295	} else if (font->width <= 16) {
2296	j = vc->vc_font.height * 2;
2297	if (font->charcount * j > FNTSIZE(fontdata))
2298	return -EINVAL;
2299
2300	for (i = 0; i < font->charcount; i++) {
2301	memcpy(data, fontdata, j);
2302	memset(data + j, 0, 2*vpitch - j);
2303	data += 2*vpitch;
2304	fontdata += j;
2305	}
2306	} else if (font->width <= 24) {
2307	if (font->charcount * (vc->vc_font.height * sizeof(u32)) > FNTSIZE(fontdata))
2308	return -EINVAL;
2309
2310	for (i = 0; i < font->charcount; i++) {
2311	for (j = 0; j < vc->vc_font.height; j++) {
2312	*data++ = fontdata[0];
2313	*data++ = fontdata[1];
2314	*data++ = fontdata[2];
2315	fontdata += sizeof(u32);
2316	}
2317	memset(data, 0, 3 * (vpitch - j));
2318	data += 3 * (vpitch - j);
2319	}
2320	} else {
2321	j = vc->vc_font.height * 4;
2322	if (font->charcount * j > FNTSIZE(fontdata))
2323	return -EINVAL;
2324
2325	for (i = 0; i < font->charcount; i++) {
2326	memcpy(data, fontdata, j);
2327	memset(data + j, 0, 4 * vpitch - j);
2328	data += 4 * vpitch;
2329	fontdata += j;
2330	}
2331	}
2332	return 0;
2333	}
2334
2335	/* set/clear vc_hi_font_mask and update vc attrs accordingly */
2336	static void set_vc_hi_font(struct vc_data *vc, bool set)
2337	{
2338	if (!set) {
2339	vc->vc_hi_font_mask = 0;
2340	if (vc->vc_can_do_color) {
2341	vc->vc_complement_mask >>= 1;
2342	vc->vc_s_complement_mask >>= 1;
2343	}
2344
2345	/* ++Edmund: reorder the attribute bits */
2346	if (vc->vc_can_do_color) {
2347	unsigned short *cp =
2348	(unsigned short *) vc->vc_origin;
2349	int count = vc->vc_screenbuf_size / 2;
2350	unsigned short c;
2351	for (; count > 0; count--, cp++) {
2352	c = scr_readw(cp);
2353	scr_writew(((c & 0xfe00) >> 1) |
2354	(c & 0xff), cp);
2355	}
2356	c = vc->vc_video_erase_char;
2357	vc->vc_video_erase_char =
2358	((c & 0xfe00) >> 1) | (c & 0xff);
2359	vc->vc_attr >>= 1;
2360	}
2361	} else {
2362	vc->vc_hi_font_mask = 0x100;
2363	if (vc->vc_can_do_color) {
2364	vc->vc_complement_mask <<= 1;
2365	vc->vc_s_complement_mask <<= 1;
2366	}
2367
2368	/* ++Edmund: reorder the attribute bits */
2369	{
2370	unsigned short *cp =
2371	(unsigned short *) vc->vc_origin;
2372	int count = vc->vc_screenbuf_size / 2;
2373	unsigned short c;
2374	for (; count > 0; count--, cp++) {
2375	unsigned short newc;
2376	c = scr_readw(cp);
2377	if (vc->vc_can_do_color)
2378	newc =
2379	((c & 0xff00) << 1) | (c &
2380	0xff);
2381	else
2382	newc = c & ~0x100;
2383	scr_writew(newc, cp);
2384	}
2385	c = vc->vc_video_erase_char;
2386	if (vc->vc_can_do_color) {
2387	vc->vc_video_erase_char =
2388	((c & 0xff00) << 1) | (c & 0xff);
2389	vc->vc_attr <<= 1;
2390	} else
2391	vc->vc_video_erase_char = c & ~0x100;
2392	}
2393	}
2394	}
2395
2396	static int fbcon_do_set_font(struct vc_data *vc, int w, int h, int charcount,
2397	const u8 * data, int userfont)
2398	{
2399	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
2400	struct fbcon_ops *ops = info->fbcon_par;
2401	struct fbcon_display *p = &fb_display[vc->vc_num];
2402	int resize, ret, old_userfont, old_width, old_height, old_charcount;
2403	char *old_data = NULL;
2404
2405	resize = (w != vc->vc_font.width) || (h != vc->vc_font.height);
2406	if (p->userfont)
2407	old_data = vc->vc_font.data;
2408	vc->vc_font.data = (void *)(p->fontdata = data);
2409	old_userfont = p->userfont;
2410	if ((p->userfont = userfont))
2411	REFCOUNT(data)++;
2412
2413	old_width = vc->vc_font.width;
2414	old_height = vc->vc_font.height;
2415	old_charcount = vc->vc_font.charcount;
2416
2417	vc->vc_font.width = w;
2418	vc->vc_font.height = h;
2419	vc->vc_font.charcount = charcount;
2420	if (vc->vc_hi_font_mask && charcount == 256)
2421	set_vc_hi_font(vc, set: false);
2422	else if (!vc->vc_hi_font_mask && charcount == 512)
2423	set_vc_hi_font(vc, set: true);
2424
2425	if (resize) {
2426	int cols, rows;
2427
2428	cols = FBCON_SWAP(ops->rotate, info->var.xres, info->var.yres);
2429	rows = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres);
2430	cols /= w;
2431	rows /= h;
2432	ret = vc_resize(vc, cols, lines: rows);
2433	if (ret)
2434	goto err_out;
2435	} else if (con_is_visible(vc)
2436	&& vc->vc_mode == KD_TEXT) {
2437	fbcon_clear_margins(vc, bottom_only: 0);
2438	update_screen(vc);
2439	}
2440
2441	if (old_data && (--REFCOUNT(old_data) == 0))
2442	kfree(objp: old_data - FONT_EXTRA_WORDS * sizeof(int));
2443	return 0;
2444
2445	err_out:
2446	p->fontdata = old_data;
2447	vc->vc_font.data = (void *)old_data;
2448
2449	if (userfont) {
2450	p->userfont = old_userfont;
2451	if (--REFCOUNT(data) == 0)
2452	kfree(objp: data - FONT_EXTRA_WORDS * sizeof(int));
2453	}
2454
2455	vc->vc_font.width = old_width;
2456	vc->vc_font.height = old_height;
2457	vc->vc_font.charcount = old_charcount;
2458
2459	return ret;
2460	}
2461
2462	/*
2463	* User asked to set font; we are guaranteed that charcount does not exceed 512
2464	* but lets not assume that, since charcount of 512 is small for unicode support.
2465	*/
2466
2467	static int fbcon_set_font(struct vc_data *vc, struct console_font *font,
2468	unsigned int vpitch, unsigned int flags)
2469	{
2470	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
2471	unsigned charcount = font->charcount;
2472	int w = font->width;
2473	int h = font->height;
2474	int size;
2475	int i, csum;
2476	u8 *new_data, *data = font->data;
2477	int pitch = PITCH(font->width);
2478
2479	/* Is there a reason why fbconsole couldn't handle any charcount >256?
2480	* If not this check should be changed to charcount < 256 */
2481	if (charcount != 256 && charcount != 512)
2482	return -EINVAL;
2483
2484	/* font bigger than screen resolution ? */
2485	if (w > FBCON_SWAP(info->var.rotate, info->var.xres, info->var.yres) ||
2486	h > FBCON_SWAP(info->var.rotate, info->var.yres, info->var.xres))
2487	return -EINVAL;
2488
2489	if (font->width > 32 || font->height > 32)
2490	return -EINVAL;
2491
2492	/* Make sure drawing engine can handle the font */
2493	if (!(info->pixmap.blit_x & BIT(font->width - 1)) ||
2494	!(info->pixmap.blit_y & BIT(font->height - 1)))
2495	return -EINVAL;
2496
2497	/* Make sure driver can handle the font length */
2498	if (fbcon_invalid_charcount(info, charcount))
2499	return -EINVAL;
2500
2501	size = CALC_FONTSZ(h, pitch, charcount);
2502
2503	new_data = kmalloc(FONT_EXTRA_WORDS * sizeof(int) + size, GFP_USER);
2504
2505	if (!new_data)
2506	return -ENOMEM;
2507
2508	memset(new_data, 0, FONT_EXTRA_WORDS * sizeof(int));
2509
2510	new_data += FONT_EXTRA_WORDS * sizeof(int);
2511	FNTSIZE(new_data) = size;
2512	REFCOUNT(new_data) = 0; /* usage counter */
2513	for (i=0; i< charcount; i++) {
2514	memcpy(new_data + i*h*pitch, data + i*vpitch*pitch, h*pitch);
2515	}
2516
2517	/* Since linux has a nice crc32 function use it for counting font
2518	* checksums. */
2519	csum = crc32(0, new_data, size);
2520
2521	FNTSUM(new_data) = csum;
2522	/* Check if the same font is on some other console already */
2523	for (i = first_fb_vc; i <= last_fb_vc; i++) {
2524	struct vc_data *tmp = vc_cons[i].d;
2525
2526	if (fb_display[i].userfont &&
2527	fb_display[i].fontdata &&
2528	FNTSUM(fb_display[i].fontdata) == csum &&
2529	FNTSIZE(fb_display[i].fontdata) == size &&
2530	tmp->vc_font.width == w &&
2531	!memcmp(p: fb_display[i].fontdata, q: new_data, size)) {
2532	kfree(objp: new_data - FONT_EXTRA_WORDS * sizeof(int));
2533	new_data = (u8 *)fb_display[i].fontdata;
2534	break;
2535	}
2536	}
2537	return fbcon_do_set_font(vc, w: font->width, h: font->height, charcount, data: new_data, userfont: 1);
2538	}
2539
2540	static int fbcon_set_def_font(struct vc_data *vc, struct console_font *font, char *name)
2541	{
2542	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
2543	const struct font_desc *f;
2544
2545	if (!name)
2546	f = get_default_font(xres: info->var.xres, yres: info->var.yres,
2547	font_w: info->pixmap.blit_x, font_h: info->pixmap.blit_y);
2548	else if (!(f = find_font(name)))
2549	return -ENOENT;
2550
2551	font->width = f->width;
2552	font->height = f->height;
2553	return fbcon_do_set_font(vc, w: f->width, h: f->height, charcount: f->charcount, data: f->data, userfont: 0);
2554	}
2555
2556	static u16 palette_red[16];
2557	static u16 palette_green[16];
2558	static u16 palette_blue[16];
2559
2560	static struct fb_cmap palette_cmap = {
2561	0, 16, palette_red, palette_green, palette_blue, NULL
2562	};
2563
2564	static void fbcon_set_palette(struct vc_data *vc, const unsigned char *table)
2565	{
2566	struct fb_info *info = fbcon_info_from_console(console: vc->vc_num);
2567	int i, j, k, depth;
2568	u8 val;
2569
2570	if (fbcon_is_inactive(vc, info))
2571	return;
2572
2573	if (!con_is_visible(vc))
2574	return;
2575
2576	depth = fb_get_color_depth(var: &info->var, fix: &info->fix);
2577	if (depth > 3) {
2578	for (i = j = 0; i < 16; i++) {
2579	k = table[i];
2580	val = vc->vc_palette[j++];
2581	palette_red[k] = (val << 8) | val;
2582	val = vc->vc_palette[j++];
2583	palette_green[k] = (val << 8) | val;
2584	val = vc->vc_palette[j++];
2585	palette_blue[k] = (val << 8) | val;
2586	}
2587	palette_cmap.len = 16;
2588	palette_cmap.start = 0;
2589	/*
2590	* If framebuffer is capable of less than 16 colors,
2591	* use default palette of fbcon.
2592	*/
2593	} else
2594	fb_copy_cmap(from: fb_default_cmap(len: 1 << depth), to: &palette_cmap);
2595
2596	fb_set_cmap(cmap: &palette_cmap, fb_info: info);
2597	}
2598
2599	static u16 *fbcon_screen_pos(const struct vc_data *vc, int offset)
2600	{
2601	return (u16 *) (vc->vc_origin + offset);
2602	}
2603
2604	static unsigned long fbcon_getxy(struct vc_data *vc, unsigned long pos,
2605	int *px, int *py)
2606	{
2607	unsigned long ret;
2608	int x, y;
2609
2610	if (pos >= vc->vc_origin && pos < vc->vc_scr_end) {
2611	unsigned long offset = (pos - vc->vc_origin) / 2;
2612
2613	x = offset % vc->vc_cols;
2614	y = offset / vc->vc_cols;
2615	ret = pos + (vc->vc_cols - x) * 2;
2616	} else {
2617	/* Should not happen */
2618	x = y = 0;
2619	ret = vc->vc_origin;
2620	}
2621	if (px)
2622	*px = x;
2623	if (py)
2624	*py = y;
2625	return ret;
2626	}
2627
2628	/* As we might be inside of softback, we may work with non-contiguous buffer,
2629	that's why we have to use a separate routine. */
2630	static void fbcon_invert_region(struct vc_data *vc, u16 * p, int cnt)
2631	{
2632	while (cnt--) {
2633	u16 a = scr_readw(p);
2634	if (!vc->vc_can_do_color)
2635	a ^= 0x0800;
2636	else if (vc->vc_hi_font_mask == 0x100)
2637	a = ((a) & 0x11ff) | (((a) & 0xe000) >> 4) |
2638	(((a) & 0x0e00) << 4);
2639	else
2640	a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) |
2641	(((a) & 0x0700) << 4);
2642	scr_writew(a, p++);
2643	}
2644	}
2645
2646	void fbcon_suspended(struct fb_info *info)
2647	{
2648	struct vc_data *vc = NULL;
2649	struct fbcon_ops *ops = info->fbcon_par;
2650
2651	if (!ops || ops->currcon < 0)
2652	return;
2653	vc = vc_cons[ops->currcon].d;
2654
2655	/* Clear cursor, restore saved data */
2656	fbcon_cursor(vc, CM_ERASE);
2657	}
2658
2659	void fbcon_resumed(struct fb_info *info)
2660	{
2661	struct vc_data *vc;
2662	struct fbcon_ops *ops = info->fbcon_par;
2663
2664	if (!ops || ops->currcon < 0)
2665	return;
2666	vc = vc_cons[ops->currcon].d;
2667
2668	update_screen(vc);
2669	}
2670
2671	static void fbcon_modechanged(struct fb_info *info)
2672	{
2673	struct fbcon_ops *ops = info->fbcon_par;
2674	struct vc_data *vc;
2675	struct fbcon_display *p;
2676	int rows, cols;
2677
2678	if (!ops || ops->currcon < 0)
2679	return;
2680	vc = vc_cons[ops->currcon].d;
2681	if (vc->vc_mode != KD_TEXT ||
2682	fbcon_info_from_console(console: ops->currcon) != info)
2683	return;
2684
2685	p = &fb_display[vc->vc_num];
2686	set_blitting_type(vc, info);
2687
2688	if (con_is_visible(vc)) {
2689	var_to_display(disp: p, var: &info->var, info);
2690	cols = FBCON_SWAP(ops->rotate, info->var.xres, info->var.yres);
2691	rows = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres);
2692	cols /= vc->vc_font.width;
2693	rows /= vc->vc_font.height;
2694	vc_resize(vc, cols, lines: rows);
2695	updatescrollmode(p, info, vc);
2696	scrollback_max = 0;
2697	scrollback_current = 0;
2698
2699	if (!fbcon_is_inactive(vc, info)) {
2700	ops->var.xoffset = ops->var.yoffset = p->yscroll = 0;
2701	ops->update_start(info);
2702	}
2703
2704	fbcon_set_palette(vc, table: color_table);
2705	update_screen(vc);
2706	}
2707	}
2708
2709	static void fbcon_set_all_vcs(struct fb_info *info)
2710	{
2711	struct fbcon_ops *ops = info->fbcon_par;
2712	struct vc_data *vc;
2713	struct fbcon_display *p;
2714	int i, rows, cols, fg = -1;
2715
2716	if (!ops || ops->currcon < 0)
2717	return;
2718
2719	for (i = first_fb_vc; i <= last_fb_vc; i++) {
2720	vc = vc_cons[i].d;
2721	if (!vc || vc->vc_mode != KD_TEXT ||
2722	fbcon_info_from_console(console: i) != info)
2723	continue;
2724
2725	if (con_is_visible(vc)) {
2726	fg = i;
2727	continue;
2728	}
2729
2730	p = &fb_display[vc->vc_num];
2731	set_blitting_type(vc, info);
2732	var_to_display(disp: p, var: &info->var, info);
2733	cols = FBCON_SWAP(ops->rotate, info->var.xres, info->var.yres);
2734	rows = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres);
2735	cols /= vc->vc_font.width;
2736	rows /= vc->vc_font.height;
2737	vc_resize(vc, cols, lines: rows);
2738	}
2739
2740	if (fg != -1)
2741	fbcon_modechanged(info);
2742	}
2743
2744
2745	void fbcon_update_vcs(struct fb_info *info, bool all)
2746	{
2747	if (all)
2748	fbcon_set_all_vcs(info);
2749	else
2750	fbcon_modechanged(info);
2751	}
2752	EXPORT_SYMBOL(fbcon_update_vcs);
2753
2754	/* let fbcon check if it supports a new screen resolution */
2755	int fbcon_modechange_possible(struct fb_info *info, struct fb_var_screeninfo *var)
2756	{
2757	struct fbcon_ops *ops = info->fbcon_par;
2758	struct vc_data *vc;
2759	unsigned int i;
2760
2761	WARN_CONSOLE_UNLOCKED();
2762
2763	if (!ops)
2764	return 0;
2765
2766	/* prevent setting a screen size which is smaller than font size */
2767	for (i = first_fb_vc; i <= last_fb_vc; i++) {
2768	vc = vc_cons[i].d;
2769	if (!vc || vc->vc_mode != KD_TEXT ||
2770	fbcon_info_from_console(console: i) != info)
2771	continue;
2772
2773	if (vc->vc_font.width > FBCON_SWAP(var->rotate, var->xres, var->yres) ||
2774	vc->vc_font.height > FBCON_SWAP(var->rotate, var->yres, var->xres))
2775	return -EINVAL;
2776	}
2777
2778	return 0;
2779	}
2780	EXPORT_SYMBOL_GPL(fbcon_modechange_possible);
2781
2782	int fbcon_mode_deleted(struct fb_info *info,
2783	struct fb_videomode *mode)
2784	{
2785	struct fb_info *fb_info;
2786	struct fbcon_display *p;
2787	int i, j, found = 0;
2788
2789	/* before deletion, ensure that mode is not in use */
2790	for (i = first_fb_vc; i <= last_fb_vc; i++) {
2791	j = con2fb_map[i];
2792	if (j == -1)
2793	continue;
2794	fb_info = fbcon_registered_fb[j];
2795	if (fb_info != info)
2796	continue;
2797	p = &fb_display[i];
2798	if (!p || !p->mode)
2799	continue;
2800	if (fb_mode_is_equal(mode1: p->mode, mode2: mode)) {
2801	found = 1;
2802	break;
2803	}
2804	}
2805	return found;
2806	}
2807
2808	#ifdef CONFIG_VT_HW_CONSOLE_BINDING
2809	static void fbcon_unbind(void)
2810	{
2811	int ret;
2812
2813	ret = do_unbind_con_driver(csw: &fb_con, first: first_fb_vc, last: last_fb_vc,
2814	deflt: fbcon_is_default);
2815
2816	if (!ret)
2817	fbcon_has_console_bind = 0;
2818	}
2819	#else
2820	static inline void fbcon_unbind(void) {}
2821	#endif /* CONFIG_VT_HW_CONSOLE_BINDING */
2822
2823	void fbcon_fb_unbind(struct fb_info *info)
2824	{
2825	int i, new_idx = -1;
2826	int idx = info->node;
2827
2828	console_lock();
2829
2830	if (!fbcon_has_console_bind) {
2831	console_unlock();
2832	return;
2833	}
2834
2835	for (i = first_fb_vc; i <= last_fb_vc; i++) {
2836	if (con2fb_map[i] != idx &&
2837	con2fb_map[i] != -1) {
2838	new_idx = con2fb_map[i];
2839	break;
2840	}
2841	}
2842
2843	if (new_idx != -1) {
2844	for (i = first_fb_vc; i <= last_fb_vc; i++) {
2845	if (con2fb_map[i] == idx)
2846	set_con2fb_map(unit: i, newidx: new_idx, user: 0);
2847	}
2848	} else {
2849	struct fb_info *info = fbcon_registered_fb[idx];
2850
2851	/* This is sort of like set_con2fb_map, except it maps
2852	* the consoles to no device and then releases the
2853	* oldinfo to free memory and cancel the cursor blink
2854	* timer. I can imagine this just becoming part of
2855	* set_con2fb_map where new_idx is -1
2856	*/
2857	for (i = first_fb_vc; i <= last_fb_vc; i++) {
2858	if (con2fb_map[i] == idx) {
2859	con2fb_map[i] = -1;
2860	if (!search_fb_in_map(idx)) {
2861	con2fb_release_oldinfo(vc: vc_cons[i].d,
2862	oldinfo: info, NULL);
2863	}
2864	}
2865	}
2866	fbcon_unbind();
2867	}
2868
2869	console_unlock();
2870	}
2871
2872	void fbcon_fb_unregistered(struct fb_info *info)
2873	{
2874	int i, idx;
2875
2876	console_lock();
2877
2878	fbcon_registered_fb[info->node] = NULL;
2879	fbcon_num_registered_fb--;
2880
2881	if (deferred_takeover) {
2882	console_unlock();
2883	return;
2884	}
2885
2886	idx = info->node;
2887	for (i = first_fb_vc; i <= last_fb_vc; i++) {
2888	if (con2fb_map[i] == idx)
2889	con2fb_map[i] = -1;
2890	}
2891
2892	if (idx == info_idx) {
2893	info_idx = -1;
2894
2895	fbcon_for_each_registered_fb(i) {
2896	info_idx = i;
2897	break;
2898	}
2899	}
2900
2901	if (info_idx != -1) {
2902	for (i = first_fb_vc; i <= last_fb_vc; i++) {
2903	if (con2fb_map[i] == -1)
2904	con2fb_map[i] = info_idx;
2905	}
2906	}
2907
2908	if (primary_device == idx)
2909	primary_device = -1;
2910
2911	if (!fbcon_num_registered_fb)
2912	do_unregister_con_driver(csw: &fb_con);
2913	console_unlock();
2914	}
2915
2916	void fbcon_remap_all(struct fb_info *info)
2917	{
2918	int i, idx = info->node;
2919
2920	console_lock();
2921	if (deferred_takeover) {
2922	for (i = first_fb_vc; i <= last_fb_vc; i++)
2923	con2fb_map_boot[i] = idx;
2924	fbcon_map_override();
2925	console_unlock();
2926	return;
2927	}
2928
2929	for (i = first_fb_vc; i <= last_fb_vc; i++)
2930	set_con2fb_map(unit: i, newidx: idx, user: 0);
2931
2932	if (con_is_bound(csw: &fb_con)) {
2933	printk(KERN_INFO "fbcon: Remapping primary device, "
2934	"fb%i, to tty %i-%i\n", idx,
2935	first_fb_vc + 1, last_fb_vc + 1);
2936	info_idx = idx;
2937	}
2938	console_unlock();
2939	}
2940
2941	#ifdef CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY
2942	static void fbcon_select_primary(struct fb_info *info)
2943	{
2944	if (!map_override && primary_device == -1 &&
2945	fb_is_primary_device(info)) {
2946	int i;
2947
2948	printk(KERN_INFO "fbcon: %s (fb%i) is primary device\n",
2949	info->fix.id, info->node);
2950	primary_device = info->node;
2951
2952	for (i = first_fb_vc; i <= last_fb_vc; i++)
2953	con2fb_map_boot[i] = primary_device;
2954
2955	if (con_is_bound(csw: &fb_con)) {
2956	printk(KERN_INFO "fbcon: Remapping primary device, "
2957	"fb%i, to tty %i-%i\n", info->node,
2958	first_fb_vc + 1, last_fb_vc + 1);
2959	info_idx = primary_device;
2960	}
2961	}
2962
2963	}
2964	#else
2965	static inline void fbcon_select_primary(struct fb_info *info)
2966	{
2967	return;
2968	}
2969	#endif /* CONFIG_FRAMEBUFFER_DETECT_PRIMARY */
2970
2971	static bool lockless_register_fb;
2972	module_param_named_unsafe(lockless_register_fb, lockless_register_fb, bool, 0400);
2973	MODULE_PARM_DESC(lockless_register_fb,
2974	"Lockless framebuffer registration for debugging [default=off]");
2975
2976	/* called with console_lock held */
2977	static int do_fb_registered(struct fb_info *info)
2978	{
2979	int ret = 0, i, idx;
2980
2981	WARN_CONSOLE_UNLOCKED();
2982
2983	fbcon_registered_fb[info->node] = info;
2984	fbcon_num_registered_fb++;
2985
2986	idx = info->node;
2987	fbcon_select_primary(info);
2988
2989	if (deferred_takeover) {
2990	pr_info("fbcon: Deferring console take-over\n");
2991	return 0;
2992	}
2993
2994	if (info_idx == -1) {
2995	for (i = first_fb_vc; i <= last_fb_vc; i++) {
2996	if (con2fb_map_boot[i] == idx) {
2997	info_idx = idx;
2998	break;
2999	}
3000	}
3001
3002	if (info_idx != -1)
3003	ret = do_fbcon_takeover(show_logo: 1);
3004	} else {
3005	for (i = first_fb_vc; i <= last_fb_vc; i++) {
3006	if (con2fb_map_boot[i] == idx)
3007	set_con2fb_map(unit: i, newidx: idx, user: 0);
3008	}
3009	}
3010
3011	return ret;
3012	}
3013
3014	int fbcon_fb_registered(struct fb_info *info)
3015	{
3016	int ret;
3017
3018	if (!lockless_register_fb)
3019	console_lock();
3020	else
3021	atomic_inc(v: &ignore_console_lock_warning);
3022
3023	ret = do_fb_registered(info);
3024
3025	if (!lockless_register_fb)
3026	console_unlock();
3027	else
3028	atomic_dec(v: &ignore_console_lock_warning);
3029
3030	return ret;
3031	}
3032
3033	void fbcon_fb_blanked(struct fb_info *info, int blank)
3034	{
3035	struct fbcon_ops *ops = info->fbcon_par;
3036	struct vc_data *vc;
3037
3038	if (!ops || ops->currcon < 0)
3039	return;
3040
3041	vc = vc_cons[ops->currcon].d;
3042	if (vc->vc_mode != KD_TEXT ||
3043	fbcon_info_from_console(console: ops->currcon) != info)
3044	return;
3045
3046	if (con_is_visible(vc)) {
3047	if (blank)
3048	do_blank_screen(entering_gfx: 0);
3049	else
3050	do_unblank_screen(leaving_gfx: 0);
3051	}
3052	ops->blank_state = blank;
3053	}
3054
3055	void fbcon_new_modelist(struct fb_info *info)
3056	{
3057	int i;
3058	struct vc_data *vc;
3059	struct fb_var_screeninfo var;
3060	const struct fb_videomode *mode;
3061
3062	for (i = first_fb_vc; i <= last_fb_vc; i++) {
3063	if (fbcon_info_from_console(console: i) != info)
3064	continue;
3065	if (!fb_display[i].mode)
3066	continue;
3067	vc = vc_cons[i].d;
3068	display_to_var(var: &var, disp: &fb_display[i]);
3069	mode = fb_find_nearest_mode(mode: fb_display[i].mode,
3070	head: &info->modelist);
3071	fb_videomode_to_var(var: &var, mode);
3072	fbcon_set_disp(info, var: &var, unit: vc->vc_num);
3073	}
3074	}
3075
3076	void fbcon_get_requirement(struct fb_info *info,
3077	struct fb_blit_caps *caps)
3078	{
3079	struct vc_data *vc;
3080
3081	if (caps->flags) {
3082	int i, charcnt;
3083
3084	for (i = first_fb_vc; i <= last_fb_vc; i++) {
3085	vc = vc_cons[i].d;
3086	if (vc && vc->vc_mode == KD_TEXT &&
3087	info->node == con2fb_map[i]) {
3088	caps->x |= 1 << (vc->vc_font.width - 1);
3089	caps->y |= 1 << (vc->vc_font.height - 1);
3090	charcnt = vc->vc_font.charcount;
3091	if (caps->len < charcnt)
3092	caps->len = charcnt;
3093	}
3094	}
3095	} else {
3096	vc = vc_cons[fg_console].d;
3097
3098	if (vc && vc->vc_mode == KD_TEXT &&
3099	info->node == con2fb_map[fg_console]) {
3100	caps->x = 1 << (vc->vc_font.width - 1);
3101	caps->y = 1 << (vc->vc_font.height - 1);
3102	caps->len = vc->vc_font.charcount;
3103	}
3104	}
3105	}
3106
3107	int fbcon_set_con2fb_map_ioctl(void __user *argp)
3108	{
3109	struct fb_con2fbmap con2fb;
3110	int ret;
3111
3112	if (copy_from_user(to: &con2fb, from: argp, n: sizeof(con2fb)))
3113	return -EFAULT;
3114	if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES)
3115	return -EINVAL;
3116	if (con2fb.framebuffer >= FB_MAX)
3117	return -EINVAL;
3118	if (!fbcon_registered_fb[con2fb.framebuffer])
3119	request_module("fb%d", con2fb.framebuffer);
3120	if (!fbcon_registered_fb[con2fb.framebuffer]) {
3121	return -EINVAL;
3122	}
3123
3124	console_lock();
3125	ret = set_con2fb_map(unit: con2fb.console - 1,
3126	newidx: con2fb.framebuffer, user: 1);
3127	console_unlock();
3128
3129	return ret;
3130	}
3131
3132	int fbcon_get_con2fb_map_ioctl(void __user *argp)
3133	{
3134	struct fb_con2fbmap con2fb;
3135
3136	if (copy_from_user(to: &con2fb, from: argp, n: sizeof(con2fb)))
3137	return -EFAULT;
3138	if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES)
3139	return -EINVAL;
3140
3141	console_lock();
3142	con2fb.framebuffer = con2fb_map[con2fb.console - 1];
3143	console_unlock();
3144
3145	return copy_to_user(to: argp, from: &con2fb, n: sizeof(con2fb)) ? -EFAULT : 0;
3146	}
3147
3148	/*
3149	* The console `switch' structure for the frame buffer based console
3150	*/
3151
3152	static const struct consw fb_con = {
3153	.owner = THIS_MODULE,
3154	.con_startup = fbcon_startup,
3155	.con_init = fbcon_init,
3156	.con_deinit = fbcon_deinit,
3157	.con_clear = fbcon_clear,
3158	.con_putc = fbcon_putc,
3159	.con_putcs = fbcon_putcs,
3160	.con_cursor = fbcon_cursor,
3161	.con_scroll = fbcon_scroll,
3162	.con_switch = fbcon_switch,
3163	.con_blank = fbcon_blank,
3164	.con_font_set = fbcon_set_font,
3165	.con_font_get = fbcon_get_font,
3166	.con_font_default = fbcon_set_def_font,
3167	.con_set_palette = fbcon_set_palette,
3168	.con_invert_region = fbcon_invert_region,
3169	.con_screen_pos = fbcon_screen_pos,
3170	.con_getxy = fbcon_getxy,
3171	.con_resize = fbcon_resize,
3172	.con_debug_enter = fbcon_debug_enter,
3173	.con_debug_leave = fbcon_debug_leave,
3174	};
3175
3176	static ssize_t store_rotate(struct device *device,
3177	struct device_attribute *attr, const char *buf,
3178	size_t count)
3179	{
3180	struct fb_info *info;
3181	int rotate, idx;
3182	char **last = NULL;
3183
3184	console_lock();
3185	idx = con2fb_map[fg_console];
3186
3187	if (idx == -1 || fbcon_registered_fb[idx] == NULL)
3188	goto err;
3189
3190	info = fbcon_registered_fb[idx];
3191	rotate = simple_strtoul(buf, last, 0);
3192	fbcon_rotate(info, rotate);
3193	err:
3194	console_unlock();
3195	return count;
3196	}
3197
3198	static ssize_t store_rotate_all(struct device *device,
3199	struct device_attribute *attr,const char *buf,
3200	size_t count)
3201	{
3202	struct fb_info *info;
3203	int rotate, idx;
3204	char **last = NULL;
3205
3206	console_lock();
3207	idx = con2fb_map[fg_console];
3208
3209	if (idx == -1 || fbcon_registered_fb[idx] == NULL)
3210	goto err;
3211
3212	info = fbcon_registered_fb[idx];
3213	rotate = simple_strtoul(buf, last, 0);
3214	fbcon_rotate_all(info, rotate);
3215	err:
3216	console_unlock();
3217	return count;
3218	}
3219
3220	static ssize_t show_rotate(struct device *device,
3221	struct device_attribute *attr,char *buf)
3222	{
3223	struct fb_info *info;
3224	int rotate = 0, idx;
3225
3226	console_lock();
3227	idx = con2fb_map[fg_console];
3228
3229	if (idx == -1 || fbcon_registered_fb[idx] == NULL)
3230	goto err;
3231
3232	info = fbcon_registered_fb[idx];
3233	rotate = fbcon_get_rotate(info);
3234	err:
3235	console_unlock();
3236	return sysfs_emit(buf, fmt: "%d\n", rotate);
3237	}
3238
3239	static ssize_t show_cursor_blink(struct device *device,
3240	struct device_attribute *attr, char *buf)
3241	{
3242	struct fb_info *info;
3243	struct fbcon_ops *ops;
3244	int idx, blink = -1;
3245
3246	console_lock();
3247	idx = con2fb_map[fg_console];
3248
3249	if (idx == -1 || fbcon_registered_fb[idx] == NULL)
3250	goto err;
3251
3252	info = fbcon_registered_fb[idx];
3253	ops = info->fbcon_par;
3254
3255	if (!ops)
3256	goto err;
3257
3258	blink = delayed_work_pending(&ops->cursor_work);
3259	err:
3260	console_unlock();
3261	return sysfs_emit(buf, fmt: "%d\n", blink);
3262	}
3263
3264	static ssize_t store_cursor_blink(struct device *device,
3265	struct device_attribute *attr,
3266	const char *buf, size_t count)
3267	{
3268	struct fb_info *info;
3269	int blink, idx;
3270	char **last = NULL;
3271
3272	console_lock();
3273	idx = con2fb_map[fg_console];
3274
3275	if (idx == -1 || fbcon_registered_fb[idx] == NULL)
3276	goto err;
3277
3278	info = fbcon_registered_fb[idx];
3279
3280	if (!info->fbcon_par)
3281	goto err;
3282
3283	blink = simple_strtoul(buf, last, 0);
3284
3285	if (blink) {
3286	fbcon_cursor_noblink = 0;
3287	fbcon_add_cursor_work(info);
3288	} else {
3289	fbcon_cursor_noblink = 1;
3290	fbcon_del_cursor_work(info);
3291	}
3292
3293	err:
3294	console_unlock();
3295	return count;
3296	}
3297
3298	static struct device_attribute device_attrs[] = {
3299	__ATTR(rotate, S_IRUGO|S_IWUSR, show_rotate, store_rotate),
3300	__ATTR(rotate_all, S_IWUSR, NULL, store_rotate_all),
3301	__ATTR(cursor_blink, S_IRUGO|S_IWUSR, show_cursor_blink,
3302	store_cursor_blink),
3303	};
3304
3305	static int fbcon_init_device(void)
3306	{
3307	int i, error = 0;
3308
3309	fbcon_has_sysfs = 1;
3310
3311	for (i = 0; i < ARRAY_SIZE(device_attrs); i++) {
3312	error = device_create_file(device: fbcon_device, entry: &device_attrs[i]);
3313
3314	if (error)
3315	break;
3316	}
3317
3318	if (error) {
3319	while (--i >= 0)
3320	device_remove_file(dev: fbcon_device, attr: &device_attrs[i]);
3321
3322	fbcon_has_sysfs = 0;
3323	}
3324
3325	return 0;
3326	}
3327
3328	#ifdef CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER
3329	static void fbcon_register_existing_fbs(struct work_struct *work)
3330	{
3331	int i;
3332
3333	console_lock();
3334
3335	deferred_takeover = false;
3336	logo_shown = FBCON_LOGO_DONTSHOW;
3337
3338	fbcon_for_each_registered_fb(i)
3339	do_fb_registered(info: fbcon_registered_fb[i]);
3340
3341	console_unlock();
3342	}
3343
3344	static struct notifier_block fbcon_output_nb;
3345	static DECLARE_WORK(fbcon_deferred_takeover_work, fbcon_register_existing_fbs);
3346
3347	static int fbcon_output_notifier(struct notifier_block *nb,
3348	unsigned long action, void *data)
3349	{
3350	WARN_CONSOLE_UNLOCKED();
3351
3352	pr_info("fbcon: Taking over console\n");
3353
3354	dummycon_unregister_output_notifier(nb: &fbcon_output_nb);
3355
3356	/* We may get called in atomic context */
3357	schedule_work(work: &fbcon_deferred_takeover_work);
3358
3359	return NOTIFY_OK;
3360	}
3361	#endif
3362
3363	static void fbcon_start(void)
3364	{
3365	WARN_CONSOLE_UNLOCKED();
3366
3367	#ifdef CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER
3368	if (conswitchp != &dummy_con)
3369	deferred_takeover = false;
3370
3371	if (deferred_takeover) {
3372	fbcon_output_nb.notifier_call = fbcon_output_notifier;
3373	dummycon_register_output_notifier(nb: &fbcon_output_nb);
3374	return;
3375	}
3376	#endif
3377	}
3378
3379	void __init fb_console_init(void)
3380	{
3381	int i;
3382
3383	console_lock();
3384	fbcon_device = device_create(cls: fb_class, NULL, MKDEV(0, 0), NULL,
3385	fmt: "fbcon");
3386
3387	if (IS_ERR(ptr: fbcon_device)) {
3388	printk(KERN_WARNING "Unable to create device "
3389	"for fbcon; errno = %ld\n",
3390	PTR_ERR(fbcon_device));
3391	fbcon_device = NULL;
3392	} else
3393	fbcon_init_device();
3394
3395	for (i = 0; i < MAX_NR_CONSOLES; i++)
3396	con2fb_map[i] = -1;
3397
3398	fbcon_start();
3399	console_unlock();
3400	}
3401
3402	#ifdef MODULE
3403
3404	static void __exit fbcon_deinit_device(void)
3405	{
3406	int i;
3407
3408	if (fbcon_has_sysfs) {
3409	for (i = 0; i < ARRAY_SIZE(device_attrs); i++)
3410	device_remove_file(fbcon_device, &device_attrs[i]);
3411
3412	fbcon_has_sysfs = 0;
3413	}
3414	}
3415
3416	void __exit fb_console_exit(void)
3417	{
3418	#ifdef CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER
3419	console_lock();
3420	if (deferred_takeover)
3421	dummycon_unregister_output_notifier(&fbcon_output_nb);
3422	console_unlock();
3423
3424	cancel_work_sync(&fbcon_deferred_takeover_work);
3425	#endif
3426
3427	console_lock();
3428	fbcon_deinit_device();
3429	device_destroy(fb_class, MKDEV(0, 0));
3430
3431	do_unregister_con_driver(&fb_con);
3432	console_unlock();
3433	}
3434	#endif
3435