diff options
Diffstat (limited to 'packages/linux/linux-rp-2.6.22/vesafb-tng-1.0-rc2-2.6.20-rc2.patch')
| -rw-r--r-- | packages/linux/linux-rp-2.6.22/vesafb-tng-1.0-rc2-2.6.20-rc2.patch | 3141 |
1 files changed, 0 insertions, 3141 deletions
diff --git a/packages/linux/linux-rp-2.6.22/vesafb-tng-1.0-rc2-2.6.20-rc2.patch b/packages/linux/linux-rp-2.6.22/vesafb-tng-1.0-rc2-2.6.20-rc2.patch deleted file mode 100644 index b1b0fc3549..0000000000 --- a/packages/linux/linux-rp-2.6.22/vesafb-tng-1.0-rc2-2.6.20-rc2.patch +++ /dev/null @@ -1,3141 +0,0 @@ -diff --git a/Documentation/fb/vesafb.txt b/Documentation/fb/vesafb.txt -index ee277dd..93d6e6e 100644 ---- a/Documentation/fb/vesafb.txt -+++ b/Documentation/fb/vesafb.txt -@@ -2,16 +2,18 @@ - What is vesafb? - =============== - --This is a generic driver for a graphic framebuffer on intel boxes. -+Vesafb is a generic framebuffer driver for x86 and x86_64 boxes. - --The idea is simple: Turn on graphics mode at boot time with the help --of the BIOS, and use this as framebuffer device /dev/fb0, like the m68k --(and other) ports do. -+VESA BIOS Extensions Version 2.0 are required, because we need access to -+a linear frame buffer. VBE 3.0 is required if you want to use modes with a -+higher (than the standard 60 Hz) refresh rate. - --This means we decide at boot time whenever we want to run in text or --graphics mode. Switching mode later on (in protected mode) is --impossible; BIOS calls work in real mode only. VESA BIOS Extensions --Version 2.0 are required, because we need a linear frame buffer. -+The VESA framebuffer driver comes in two flavors - the standard 'vesafb' -+and 'vesafb-tng'. Vesafb-tng is available only on 32-bit x86 due to the -+technology it uses (vm86). Vesafb-tng has more features than vesafb -+(adjusting the refresh rate on VBE 3.0 compliant boards, switching the -+video mode without rebooting, selecting a mode by providing its -+modedb name, and more). - - Advantages: - -@@ -29,26 +31,35 @@ Disadvantages: - How to use it? - ============== - --Switching modes is done using the vga=... boot parameter. Read --Documentation/svga.txt for details. -+If you are running a 32-bit x86 system and you decide to use vesafb-tng, -+you can either compile the driver into the kernel or use it as a module. -+The graphics mode you want to use is in both cases specified using the -+standard modedb format. - --You should compile in both vgacon (for text mode) and vesafb (for --graphics mode). Which of them takes over the console depends on --whenever the specified mode is text or graphics. -+If your system doesn't support vm86 calls, things get a little more tricky. -+Since on such systems you can't do BIOS calls from protected mode in which -+kernel runs, you have to decide at boot time whenever you want to run in text -+or in graphics mode. Switching mode later on is impossible. Switching modes -+is done using the vga=... boot parameter. Read Documentation/svga.txt for -+details. Below is a more detailed description of what to do on systems using -+the standard vesafb driver. - --The graphic modes are NOT in the list which you get if you boot with --vga=ask and hit return. The mode you wish to use is derived from the --VESA mode number. Here are those VESA mode numbers: -+You should compile in both vgacon (for text mode) and vesafb (for graphics -+mode). Which of them takes over the console depends on whenever the -+specified mode is text or graphics. -+ -+The graphic modes are NOT in the list which you get if you boot with vga=ask -+and hit return. The mode you wish to use is derived from the VESA mode number. -+Here are those VESA mode numbers: - - | 640x480 800x600 1024x768 1280x1024 - ----+------------------------------------- --256 | 0x101 0x103 0x105 0x107 --32k | 0x110 0x113 0x116 0x119 --64k | 0x111 0x114 0x117 0x11A --16M | 0x112 0x115 0x118 0x11B -+256 | 0x101 0x103 0x105 0x107 -+32k | 0x110 0x113 0x116 0x119 -+64k | 0x111 0x114 0x117 0x11A -+16M | 0x112 0x115 0x118 0x11B - --The video mode number of the Linux kernel is the VESA mode number plus --0x200. -+The video mode number of the Linux kernel is the VESA mode number plus 0x200. - - Linux_kernel_mode_number = VESA_mode_number + 0x200 - -@@ -56,15 +67,15 @@ So the table for the Kernel mode numbers are: - - | 640x480 800x600 1024x768 1280x1024 - ----+------------------------------------- --256 | 0x301 0x303 0x305 0x307 --32k | 0x310 0x313 0x316 0x319 --64k | 0x311 0x314 0x317 0x31A --16M | 0x312 0x315 0x318 0x31B -+256 | 0x301 0x303 0x305 0x307 -+32k | 0x310 0x313 0x316 0x319 -+64k | 0x311 0x314 0x317 0x31A -+16M | 0x312 0x315 0x318 0x31B - --To enable one of those modes you have to specify "vga=ask" in the --lilo.conf file and rerun LILO. Then you can type in the desired --mode at the "vga=ask" prompt. For example if you like to use --1024x768x256 colors you have to say "305" at this prompt. -+To enable one of those modes you have to specify "vga=ask" in the lilo.conf -+file and rerun LILO. Then you can type in the desired mode at the "vga=ask" -+prompt. For example if you like to use 1024x768x256 colors you have to say -+"305" at this prompt. - - If this does not work, this might be because your BIOS does not support - linear framebuffers or because it does not support this mode at all. -@@ -72,11 +83,12 @@ Even if your board does, it might be the BIOS which does not. VESA BIOS - Extensions v2.0 are required, 1.2 is NOT sufficient. You will get a - "bad mode number" message if something goes wrong. - --1. Note: LILO cannot handle hex, for booting directly with -+1. Note: LILO cannot handle hex, for booting directly with - "vga=mode-number" you have to transform the numbers to decimal. - 2. Note: Some newer versions of LILO appear to work with those hex values, - if you set the 0x in front of the numbers. - -+ - X11 - === - -@@ -84,98 +96,164 @@ XF68_FBDev should work just fine, but it is non-accelerated. Running - another (accelerated) X-Server like XF86_SVGA might or might not work. - It depends on X-Server and graphics board. - --The X-Server must restore the video mode correctly, else you end up -+The X-Server must restore the video mode correctly, or else you end up - with a broken console (and vesafb cannot do anything about this). -+With vesafb-tng chances are that the console will be restored properly -+even if the X server messes up the video mode. - - - Refresh rates - ============= - --There is no way to change the vesafb video mode and/or timings after --booting linux. If you are not happy with the 60 Hz refresh rate, you --have these options: -+With VBE 3.0 compatible BIOSes and vesafb-tng it is possible to change -+the refresh rate either at boot time (by specifying the @<rr> part of -+the mode name) or later, using the fbset utility. -+ -+If you want to use the default BIOS refresh rate while switching modes -+on a running system, set pixclock to 0. - -- * configure and load the DOS-Tools for your the graphics board (if -- available) and boot linux with loadlin. -- * use a native driver (matroxfb/atyfb) instead if vesafb. If none -+With VBE 2.0 there is no way to change the mode timings after booting -+Linux. If you are not happy with the 60 Hz refresh rate, you have -+the following options: -+ -+ * Configure and load the DOS tools for your the graphics board (if -+ available) and boot Linux with loadlin. -+ * Use a native driver (matroxfb/atyfb) instead of vesafb. If none - is available, write a new one! -- * VBE 3.0 might work too. I have neither a gfx board with VBE 3.0 -- support nor the specs, so I have not checked this yet. -+ * Use a BIOS editor to change the default refresh rate (such an -+ editor does exist at least for ATI Radeon BIOSes). -+ * If you're running a non-vm86 and VBE 3.0 compatible system, you can -+ use a kernel patch (vesafb-rrc) to hard-code some mode timings in -+ the kernel and use these while setting the video mode at boot time. -+ -+Note that there are some boards (nVidia 59**, 57** and newer models) -+claiming that their Video BIOS is VBE 3.0 compliant, while ignoring the -+CRTC values provided by software such as vesafb-tng. You'll not be able -+to adjust the refresh rate if you're using one of these boards. - - - Configuration - ============= - --The VESA BIOS provides protected mode interface for changing --some parameters. vesafb can use it for palette changes and --to pan the display. It is turned off by default because it --seems not to work with some BIOS versions, but there are options --to turn it on. -- --You can pass options to vesafb using "video=vesafb:option" on --the kernel command line. Multiple options should be separated --by comma, like this: "video=vesafb:ypan,invers" -- --Accepted options: -- --invers no comment... -- --ypan enable display panning using the VESA protected mode -- interface. The visible screen is just a window of the -- video memory, console scrolling is done by changing the -- start of the window. -- pro: * scrolling (fullscreen) is fast, because there is -- no need to copy around data. -- * You'll get scrollback (the Shift-PgUp thing), -- the video memory can be used as scrollback buffer -- kontra: * scrolling only parts of the screen causes some -- ugly flicker effects (boot logo flickers for -- example). -- --ywrap Same as ypan, but assumes your gfx board can wrap-around -- the video memory (i.e. starts reading from top if it -- reaches the end of video memory). Faster than ypan. -- --redraw scroll by redrawing the affected part of the screen, this -- is the safe (and slow) default. -- -- --vgapal Use the standard vga registers for palette changes. -- This is the default. --pmipal Use the protected mode interface for palette changes. -- --mtrr:n setup memory type range registers for the vesafb framebuffer -- where n: -- 0 - disabled (equivalent to nomtrr) (default) -- 1 - uncachable -- 2 - write-back -- 3 - write-combining -- 4 - write-through -- -- If you see the following in dmesg, choose the type that matches the -- old one. In this example, use "mtrr:2". -+The VESA BIOS provides protected mode interface for changing some parameters. -+vesafb can use it for palette changes and to pan the display. It is turned -+off by default because it seems not to work with some BIOS versions, but -+there are options to turn it on. -+ -+You can pass options to vesafb using "video=vesafb:option" on the kernel -+command line. Multiple options should be separated by a comma, like this: -+"video=vesafb:ypan,1024x768-32@85" -+ -+Note that vesafb-tng still uses the "video=vesafb:option" format of the -+kernel command line video parameter. "video=vesafb-tng:xxx" is incorrect. -+ -+Accepted options (both vesafb and vesafb-tng): -+ -+ypan Enable display panning using the VESA protected mode interface -+ The visible screen is just a window of the video memory, -+ console scrolling is done by changing the start of the window. -+ pro: * scrolling (fullscreen) is fast, because there is -+ no need to copy around data. -+ * you'll get scrollback (the Shift-PgUp thing), -+ the video memory can be used as scrollback buffer -+ con: * scrolling only parts of the screen causes some -+ ugly flicker effects (boot logo flickers for -+ example). -+ -+ywrap Same as ypan, but assumes your gfx board can wrap-around the video -+ memory (i.e. starts reading from top if it reaches the end of -+ video memory). Faster than ypan. -+ -+redraw Scroll by redrawing the affected part of the screen, this is the -+ safe (and slow) default. -+ -+vgapal Use the standard VGA registers for palette changes. -+ -+pmipal Use the protected mode interface for palette changes. -+ This is the default is the protected mode interface is available. -+ -+mtrr:n Setup memory type range registers for the vesafb framebuffer -+ where n: -+ 0 - disabled (equivalent to nomtrr) (default) -+ 1 - uncachable -+ 2 - write-back -+ 3 - write-combining -+ 4 - write-through -+ -+ If you see the following in dmesg, choose the type that matches -+ the old one. In this example, use "mtrr:2". - ... - mtrr: type mismatch for e0000000,8000000 old: write-back new: write-combining - ... - --nomtrr disable mtrr -+nomtrr Do not use memory type range registers for vesafb. - - vremap:n - remap 'n' MiB of video RAM. If 0 or not specified, remap memory -- according to video mode. (2.5.66 patch/idea by Antonino Daplas -- reversed to give override possibility (allocate more fb memory -- than the kernel would) to 2.4 by tmb@iki.fi) -+ according to video mode. (2.5.66 patch/idea by Antonino Daplas -+ reversed to give override possibility (allocate more fb memory -+ than the kernel would) to 2.4 by tmb@iki.fi) - - vtotal:n - if the video BIOS of your card incorrectly determines the total - amount of video RAM, use this option to override the BIOS (in MiB). - --Have fun! -+Options accepted only by vesafb-tng: -+ -+<mode> The mode you want to set, in the standard modedb format. Refer to -+ modedb.txt for a detailed description. If you specify a mode that is -+ not supported by your board's BIOS, vesafb-tng will attempt to set a -+ similar mode. The list of supported modes can be found in -+ /proc/fbx/modes, where x is the framebuffer number (usually 0). -+ When vesafb-tng is compiled as a module, the mode string should be -+ provided as a value of the parameter 'mode'. -+ -+vbemode:x -+ Force the use of VBE mode x. The mode will only be set if it's -+ found in the VBE-provided list of supported modes. -+ NOTE: The mode number 'x' should be specified in VESA mode number -+ notation, not the Linux kernel one (eg. 257 instead of 769). -+ HINT: If you use this option because normal <mode> parameter does -+ not work for you and you use a X server, you'll probably want to -+ set the 'nocrtc' option to ensure that the video mode is properly -+ restored after console <-> X switches. -+ -+nocrtc Do not use CRTC timings while setting the video mode. This option -+ makes sence only with VBE 3.0 compliant systems. Use it if you have -+ problems with modes set in the standard way. Note that using this -+ option means that any refresh rate adjustments will be ignored -+ and the refresh rate will stay at your BIOS default (60 Hz). -+ -+noedid Do not try to fetch and use EDID-provided modes. -+ -+noblank Disable hardware blanking. -+ -+gtf Force the use of VESA's GTF (Generalized Timing Formula). Specifying -+ this will cause vesafb to skip its internal modedb and EDID-modedb -+ and jump straight to the GTF part of the code (normally used only if -+ everything else failed). This can be useful if you want to get as -+ much as possible from your graphics board but your BIOS doesn't -+ support modes with the refresh rates you require. Note that you may -+ need to specify the maxhf, maxvf and maxclk parameters if they are not -+ provided by the EDID block. -+ -+Additionally, the following parameters may be provided. They all override the -+EDID-provided values and BIOS defaults. Refer to your monitor's specs to get -+the correct values for maxhf, maxvf and maxclk for your hardware. -+ -+maxhf:n Maximum horizontal frequency (in kHz). -+maxvf:n Maximum vertical frequency (in Hz). -+maxclk:n Maximum pixel clock (in MHz). - -- Gerd -+Have fun! - - -- -+Original document for the vesafb driver by - Gerd Knorr <kraxel@goldbach.in-berlin.de> - --Minor (mostly typo) changes --by Nico Schmoigl <schmoigl@rumms.uni-mannheim.de> -+Minor (mostly typo) changes by -+Nico Schmoigl <schmoigl@rumms.uni-mannheim.de> -+ -+Extended documentation for vm86, VBE 3.0 and vesafb-tng by -+Michal Januszewski <spock@gentoo.org> -+ -diff --git a/arch/i386/boot/video.S b/arch/i386/boot/video.S -index 2c5b5cc..2c2d4b5 100644 ---- a/arch/i386/boot/video.S -+++ b/arch/i386/boot/video.S -@@ -163,10 +163,12 @@ basret: ret - # parameters in the default 80x25 mode -- these are set directly, - # because some very obscure BIOSes supply insane values. - mode_params: -+#ifdef CONFIG_FB_VESA_STD - #ifdef CONFIG_VIDEO_SELECT - cmpb $0, graphic_mode - jnz mopar_gr - #endif -+#endif - movb $0x03, %ah # Read cursor position - xorb %bh, %bh - int $0x10 -@@ -199,6 +201,7 @@ mopar2: movb %al, %fs:(PARAM_VIDEO_LINES) - ret - - #ifdef CONFIG_VIDEO_SELECT -+#ifdef CONFIG_FB_VESA_STD - # Fetching of VESA frame buffer parameters - mopar_gr: - leaw modelist+1024, %di -@@ -281,6 +284,7 @@ dac_done: - movw %es, %fs:(PARAM_VESAPM_SEG) - movw %di, %fs:(PARAM_VESAPM_OFF) - no_pm: ret -+#endif - - # The video mode menu - mode_menu: -@@ -495,10 +499,12 @@ mode_set: - - cmpb $VIDEO_FIRST_V7>>8, %ah - jz setv7 -- -+ -+#ifdef CONFIG_FB_VESA_STD - cmpb $VIDEO_FIRST_VESA>>8, %ah - jnc check_vesa -- -+#endif -+ - orb %ah, %ah - jz setmenu - -@@ -570,6 +576,7 @@ setr1: lodsw - movw -4(%si), %ax # Fetch mode ID - jmp _m_s - -+#ifdef CONFIG_FB_VESA_STD - check_vesa: - leaw modelist+1024, %di - subb $VIDEO_FIRST_VESA>>8, %bh -@@ -603,6 +610,7 @@ check_vesa: - ret - - _setbad: jmp setbad # Ugly... -+#endif - - # Recalculate vertical display end registers -- this fixes various - # inconsistencies of extended modes on many adapters. Called when -diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c -index 1393523..8a05f95 100644 ---- a/drivers/char/sysrq.c -+++ b/drivers/char/sysrq.c -@@ -240,7 +240,7 @@ static void send_sig_all(int sig) - struct task_struct *p; - - for_each_process(p) { -- if (p->mm && !is_init(p)) -+ if (p->mm && !is_init(p) && !(p->flags & PF_BORROWED_MM)) - /* Not swapper, init nor kernel thread */ - force_sig(sig, p); - } -diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig -index 4e83f01..ae122fd 100644 ---- a/drivers/video/Kconfig -+++ b/drivers/video/Kconfig -@@ -547,8 +547,22 @@ config FB_TGA - cards. Say Y if you have one of those. - - config FB_VESA -- bool "VESA VGA graphics support" -- depends on (FB = y) && X86 -+ tristate "VESA VGA graphics support" -+ depends on (FB = y) && (X86 || X86_64) -+ help -+ This is the frame buffer device driver for generic VESA 2.0 -+ compliant graphic cards. The older VESA 1.2 cards are not supported. -+ You will get a boot time penguin logo at no additional cost. Please -+ read <file:Documentation/fb/vesafb.txt>. If unsure, say Y. -+ -+choice -+ prompt "VESA driver type" -+ depends on FB_VESA -+ default FB_VESA_STD if X86_64 -+ default FB_VESA_TNG if X86 -+ -+config FB_VESA_STD -+ bool "vesafb" - select FB_CFB_FILLRECT - select FB_CFB_COPYAREA - select FB_CFB_IMAGEBLIT -@@ -557,7 +571,43 @@ config FB_VESA - This is the frame buffer device driver for generic VESA 2.0 - compliant graphic cards. The older VESA 1.2 cards are not supported. - You will get a boot time penguin logo at no additional cost. Please -- read <file:Documentation/fb/vesafb.txt>. If unsure, say Y. -+ read <file:Documentation/fb/vesafb.txt>. Choose this driver if you -+ are experiencing problems with vesafb-tng or if you own a 64-bit system. -+ -+ Note that this driver cannot be compiled as a module. -+ -+config FB_VESA_TNG -+ bool "vesafb-tng" -+ depends on !X86_64 -+ select FB_MODE_HELPERS -+ select FB_CFB_FILLRECT -+ select FB_CFB_COPYAREA -+ select FB_CFB_IMAGEBLIT -+ help -+ This is an enhanced generic frame buffer device driver for -+ VBE 2.0 compliant graphic cards. It can take advantage of VBE 3.0 -+ features (refresh rate adjustment) when these are available. -+ The driver also makes it possible to change the video mode -+ on the fly and to switch back to text mode when it's unloaded. -+ -+ If the driver is compiled as a module, the module will be called -+ vesafb-tng. -+ -+endchoice -+ -+config FB_VESA_DEFAULT_MODE -+ string "VESA default mode" -+ depends on FB_VESA_TNG -+ default "640x480@60" -+ help -+ This option is used to determine the default mode vesafb is -+ supposed to switch to in case no mode is provided as a kernel -+ command line parameter. -+ -+config VIDEO_SELECT -+ bool -+ depends on FB_VESA -+ default y - - config FB_IMAC - bool "Intel-based Macintosh Framebuffer Support" -diff --git a/drivers/video/Makefile b/drivers/video/Makefile -index 309a26d..e57b0e7 100644 ---- a/drivers/video/Makefile -+++ b/drivers/video/Makefile -@@ -102,7 +102,11 @@ obj-$(CONFIG_FB_PNX4008_DUM_RGB) += pnx4008/ - obj-$(CONFIG_FB_IBM_GXT4500) += gxt4500.o - - # Platform or fallback drivers go here --obj-$(CONFIG_FB_VESA) += vesafb.o -+ifeq ($(CONFIG_FB_VESA_STD),y) -+ obj-y += vesafb.o -+else -+ obj-$(CONFIG_FB_VESA) += vesafb-thread.o vesafb-tng.o -+endif - obj-$(CONFIG_FB_IMAC) += imacfb.o - obj-$(CONFIG_FB_VGA16) += vga16fb.o vgastate.o - obj-$(CONFIG_FB_OF) += offb.o -diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c -index 3cfea31..bfb39cc 100644 ---- a/drivers/video/fbmem.c -+++ b/drivers/video/fbmem.c -@@ -1408,6 +1408,7 @@ fbmem_init(void) - printk(KERN_WARNING "Unable to create fb class; errno = %ld\n", PTR_ERR(fb_class)); - fb_class = NULL; - } -+ - return 0; - } - -diff --git a/drivers/video/modedb.c b/drivers/video/modedb.c -index 5df41f6..f838a53 100644 ---- a/drivers/video/modedb.c -+++ b/drivers/video/modedb.c -@@ -674,6 +674,7 @@ void fb_var_to_videomode(struct fb_videomode *mode, - { - u32 pixclock, hfreq, htotal, vtotal; - -+ mode->refresh = 0; - mode->name = NULL; - mode->xres = var->xres; - mode->yres = var->yres; -@@ -1025,3 +1026,4 @@ EXPORT_SYMBOL(fb_find_best_mode); - EXPORT_SYMBOL(fb_find_nearest_mode); - EXPORT_SYMBOL(fb_videomode_to_modelist); - EXPORT_SYMBOL(fb_find_mode); -+EXPORT_SYMBOL(fb_destroy_modelist); -diff --git a/drivers/video/vesafb-thread.c b/drivers/video/vesafb-thread.c -new file mode 100644 -index 0000000..543e202 ---- /dev/null -+++ b/drivers/video/vesafb-thread.c -@@ -0,0 +1,751 @@ -+/* -+ * Framebuffer driver for VBE 2.0+ compliant graphic boards. -+ * Kernel thread and vm86 routines. -+ * -+ * (c) 2004-2006 Michal Januszewski <spock@gentoo.org> -+ * -+ */ -+ -+#include <linux/workqueue.h> -+#include <linux/completion.h> -+#include <linux/module.h> -+#include <linux/kernel.h> -+#include <linux/errno.h> -+#include <linux/mm.h> -+#include <linux/delay.h> -+#include <linux/signal.h> -+#include <linux/freezer.h> -+#include <linux/suspend.h> -+#include <linux/unistd.h> -+#include <video/vesa.h> -+#include <video/edid.h> -+#include <asm/mman.h> -+#include <asm/page.h> -+#include <asm/vm86.h> -+#include <asm/thread_info.h> -+#include <asm/uaccess.h> -+#include <asm/mmu_context.h> -+#include "edid.h" -+ -+static int errno; -+ -+static DECLARE_COMPLETION(vesafb_th_completion); -+static DECLARE_MUTEX(vesafb_task_list_sem); -+static LIST_HEAD(vesafb_task_list); -+static DECLARE_WAIT_QUEUE_HEAD(vesafb_wait); -+ -+static struct vm86_struct vm86; -+static int vesafb_pid = 0; -+ -+#define DEFAULT_VM86_FLAGS (IF_MASK | IOPL_MASK) -+#define VM86_PUSHW(x) \ -+do { \ -+ vm86.regs.esp -= 2; \ -+ *(u16*)(STACK_ADDR + vm86.regs.esp) = x; \ -+} while(0); -+ -+/* Stack, the return code and buffers will be put into -+ * one contiguous memory chunk: -+ * -+ * [ STACK | RET_CODE | BUFFER ] -+ * -+ * Some video BIOSes (sis6326) try to store data somewhere -+ * in 0x7000-0x7fff, so we zeromap more memory to be safe. -+ */ -+#define IVTBDA_SIZE PAGE_SIZE -+#define RET_CODE_SIZE 0x0010 -+#define STACK_SIZE 0x0500 -+#define BUFFER_SIZE 0x10000 -+ -+/* The amount of memory that will be allocated should be a multiple -+ * of PAGE_SIZE. */ -+#define __MEM_SIZE (RET_CODE_SIZE + STACK_SIZE + BUFFER_SIZE) -+#define REAL_MEM_SIZE (((__MEM_SIZE / PAGE_SIZE) + 1) * PAGE_SIZE) -+ -+#define IVTBDA_ADDR 0x00000 -+#define STACK_ADDR (IVTBDA_ADDR + IVTBDA_SIZE) -+#define RET_CODE_ADDR (STACK_ADDR + STACK_SIZE) -+#define BUF_ADDR (RET_CODE_ADDR + RET_CODE_SIZE) -+ -+#define FLAG_D (1 << 10) -+ -+/* Syscalls used by the vesafb thread */ -+static int vm86old(struct vm86_struct __user* v86) -+{ -+ long res; -+ __asm__ volatile ("push %%ebx; movl %2, %%ebx ; int $0x80 ; pop %%ebx" -+ : "=a" (res) -+ : "0" (__NR_vm86old), "ri" ((long)(v86)) : "memory"); -+ -+ if ((unsigned long)(res) >= (unsigned long)(-MAX_ERRNO)) { -+ errno = -res; -+ res = -1; -+ } -+ return (int)res; -+} -+ -+static int ioperm(unsigned long a, unsigned long b, unsigned long c) -+{ -+ long res; -+ __asm__ volatile ("push %%ebx; movl %2, %%ebx ; int $0x80 ; pop %%ebx" -+ : "=a" (res) -+ : "0" (__NR_ioperm), "ri" ((long)(a)), "c" ((long)(b)), -+ "d" ((long)(c)) : "memory"); -+ -+ if ((unsigned long)(res) >= (unsigned long)(-MAX_ERRNO)) { -+ errno = -res; -+ res = -1; -+ } -+ return (int)res; -+} -+ -+/* Segment prefix opcodes */ -+enum { -+ P_CS = 0x2e, -+ P_SS = 0x36, -+ P_DS = 0x3e, -+ P_ES = 0x26, -+ P_FS = 0x64, -+ P_GS = 0x65 -+}; -+ -+/* Emulated vm86 ins instruction */ -+static void vm86_ins(int size) -+{ -+ u32 edx, edi; -+ edx = vm86.regs.edx & 0xffff; -+ edi = (vm86.regs.edi & 0xffff) + (u32)(vm86.regs.es << 4); -+ -+ if (vm86.regs.eflags & FLAG_D) -+ asm volatile ("std\n"); -+ else -+ asm volatile ("cld\n"); -+ -+ switch (size) { -+ case 4: -+ asm volatile ("insl\n" : "=D" (edi) : "d" (edx), "0" (edi)); -+ break; -+ case 2: -+ asm volatile ("insw\n" : "=D" (edi) : "d" (edx), "0" (edi)); -+ break; -+ case 1: -+ asm volatile ("insb\n" : "=D" (edi) : "d" (edx), "0" (edi)); -+ break; -+ } -+ -+ if (vm86.regs.eflags & FLAG_D) -+ asm volatile ("cld\n"); -+ -+ edi -= (u32)(vm86.regs.es << 4); -+ -+ vm86.regs.edi &= 0xffff0000; -+ vm86.regs.edi |= edi & 0xffff; -+} -+ -+static void vm86_rep_ins(int size) -+{ -+ u16 cx = vm86.regs.ecx; -+ while (cx--) -+ vm86_ins(size); -+ -+ vm86.regs.ecx &= 0xffff0000; -+} -+ -+/* Emulated vm86 outs instruction */ -+static void vm86_outs(int size, int segment) -+{ -+ u32 edx, esi, base; -+ -+ edx = vm86.regs.edx & 0xffff; -+ esi = vm86.regs.esi & 0xffff; -+ -+ switch (segment) { -+ case P_CS: base = vm86.regs.cs; break; -+ case P_SS: base = vm86.regs.ss; break; -+ case P_ES: base = vm86.regs.es; break; -+ case P_FS: base = vm86.regs.fs; break; -+ case P_GS: base = vm86.regs.gs; break; -+ default: base = vm86.regs.ds; break; -+ } -+ -+ esi += base << 4; -+ -+ if (vm86.regs.eflags & FLAG_D) -+ asm volatile ("std\n"); -+ else -+ asm volatile ("cld\n"); -+ -+ switch (size) { -+ case 4: -+ asm volatile ("outsl\n" : "=S" (esi) : "d" (edx), "0" (esi)); -+ break; -+ case 2: -+ asm volatile ("outsw\n" : "=S" (esi) : "d" (edx), "0" (esi)); -+ break; -+ case 1: -+ asm volatile ("outsb\n" : "=S" (esi) : "d" (edx), "0" (esi)); -+ break; -+ } -+ -+ if (vm86.regs.eflags & FLAG_D) -+ asm volatile ("cld"); -+ -+ esi -= base << 4; -+ vm86.regs.esi &= 0xffff0000; -+ vm86.regs.esi |= (esi & 0xffff); -+} -+ -+static void vm86_rep_outs(int size, int segment) -+{ -+ u16 cx = vm86.regs.ecx; -+ while (cx--) -+ vm86_outs(size, segment); -+ -+ vm86.regs.ecx &= 0xffff0000; -+} -+ -+static int vm86_do_unknown(void) -+{ -+ u8 data32 = 0, segment = P_DS, rep = 0; -+ u8 *instr; -+ int ret = 0, i = 0; -+ -+ instr = (u8*)((vm86.regs.cs << 4) + vm86.regs.eip); -+ -+ while (1) { -+ switch(instr[i]) { -+ case 0x66: /* operand size prefix */ -+ data32 = 1 - data32; -+ i++; -+ break; -+ case 0xf2: /* repnz */ -+ case 0xf3: /* rep */ -+ rep = 1; -+ i++; -+ break; -+ case P_CS: /* segment prefix */ -+ case P_SS: -+ case P_DS: -+ case P_ES: -+ case P_FS: -+ case P_GS: -+ segment = instr[i]; -+ i++; -+ break; -+ case 0xf0: /* LOCK - ignored */ -+ case 0x67: /* address size prefix - ignored */ -+ i++; -+ break; -+ case 0x6c: /* insb */ -+ if (rep) -+ vm86_rep_ins(1); -+ else -+ vm86_ins(1); -+ i++; -+ goto out; -+ case 0x6d: /* insw / insd */ -+ if (rep) { -+ if (data32) -+ vm86_rep_ins(4); -+ else -+ vm86_rep_ins(2); -+ } else { -+ if (data32) -+ vm86_ins(4); -+ else -+ vm86_ins(2); -+ } -+ i++; -+ goto out; -+ case 0x6e: /* outsb */ -+ if (rep) -+ vm86_rep_outs(1, segment); -+ else -+ vm86_outs(1, segment); -+ i++; -+ goto out; -+ case 0x6f: /* outsw / outsd */ -+ if (rep) { -+ if (data32) -+ vm86_rep_outs(4, segment); -+ else -+ vm86_rep_outs(2, segment); -+ } else { -+ if (data32) -+ vm86_outs(4, segment); -+ else -+ vm86_outs(2, segment); -+ } -+ i++; -+ goto out; -+ case 0xe4: /* inb xx */ -+ asm volatile ( -+ "inb %w1, %b0" -+ : "=a" (vm86.regs.eax) -+ : "d" (instr[i+1]), "0" (vm86.regs.eax)); -+ i += 2; -+ goto out; -+ case 0xe5: /* inw xx / ind xx */ -+ if (data32) { -+ asm volatile ( -+ "inl %w1, %0" -+ : "=a" (vm86.regs.eax) -+ : "d" (instr[i+1]), -+ "0" (vm86.regs.eax)); -+ } else { -+ asm volatile ( -+ "inw %w1, %w0" -+ : "=a" (vm86.regs.eax) -+ : "d" (instr[i+1]), -+ "0" (vm86.regs.eax)); -+ } -+ i += 2; -+ goto out; -+ -+ case 0xec: /* inb dx */ -+ asm volatile ( -+ "inb %w1, %b0" -+ : "=a" (vm86.regs.eax) -+ : "d" (vm86.regs.edx), "0" (vm86.regs.eax)); -+ i++; -+ goto out; -+ case 0xed: /* inw dx / ind dx */ -+ if (data32) { -+ asm volatile ( -+ "inl %w1, %0" -+ : "=a" (vm86.regs.eax) -+ : "d" (vm86.regs.edx)); -+ } else { -+ asm volatile ( -+ "inw %w1, %w0" -+ : "=a" (vm86.regs.eax) -+ : "d" (vm86.regs.edx)); -+ } -+ i++; -+ goto out; -+ case 0xe6: /* outb xx */ -+ asm volatile ( -+ "outb %b0, %w1" -+ : /* no return value */ -+ : "a" (vm86.regs.eax), "d" (instr[i+1])); -+ i += 2; -+ goto out; -+ case 0xe7: /* outw xx / outd xx */ -+ if (data32) { -+ asm volatile ( -+ "outl %0, %w1" -+ : /* no return value */ -+ : "a" (vm86.regs.eax), -+ "d" (instr[i+1])); -+ } else { -+ asm volatile ( -+ "outw %w0, %w1" -+ : /* no return value */ -+ : "a" (vm86.regs.eax), -+ "d" (instr[i+1])); -+ } -+ i += 2; -+ goto out; -+ case 0xee: /* outb dx */ -+ asm volatile ( -+ "outb %b0, %w1" -+ : /* no return value */ -+ : "a" (vm86.regs.eax), "d" (vm86.regs.edx)); -+ i++; -+ goto out; -+ case 0xef: /* outw dx / outd dx */ -+ if (data32) { -+ asm volatile ( -+ "outl %0, %w1" -+ : /* no return value */ -+ : "a" (vm86.regs.eax), -+ "d" (vm86.regs.edx)); -+ } else { -+ asm volatile ( -+ "outw %w0, %w1" -+ : /* no return value */ -+ : "a" (vm86.regs.eax), -+ "d" (vm86.regs.edx)); -+ } -+ i++; -+ goto out; -+ default: -+ printk(KERN_ERR "vesafb: BUG, opcode 0x%x emulation " -+ "not supported (EIP: 0x%lx)\n", -+ instr[i], (u32)(vm86.regs.cs << 4) + -+ vm86.regs.eip); -+ ret = 1; -+ goto out; -+ } -+ } -+out: vm86.regs.eip += i; -+ return ret; -+} -+ -+void vesafb_do_vm86(struct vm86_regs *regs) -+{ -+ unsigned int ret; -+ u8 *retcode = (void*)RET_CODE_ADDR; -+ -+ memset(&vm86,0,sizeof(vm86)); -+ memcpy(&vm86.regs, regs, sizeof(struct vm86_regs)); -+ -+ /* The return code */ -+ retcode[0] = 0xcd; /* int opcode */ -+ retcode[1] = 0xff; /* int number (255) */ -+ -+ /* We use int 0xff to get back to protected mode */ -+ memset(&vm86.int_revectored, 0, sizeof(vm86.int_revectored)); -+ ((unsigned char *)&vm86.int_revectored)[0xff / 8] |= (1 << (0xff % 8)); -+ -+ /* -+ * We want to call int 0x10, so we set: -+ * CS = 0x42 = 0x10 * 4 + 2 -+ * IP = 0x40 = 0x10 * 4 -+ * and SS:ESP. It's up to the caller to set the rest of the registers. -+ */ -+ vm86.regs.eflags = DEFAULT_VM86_FLAGS; -+ vm86.regs.cs = *(unsigned short *)0x42; -+ vm86.regs.eip = *(unsigned short *)0x40; -+ vm86.regs.ss = (STACK_ADDR >> 4); -+ vm86.regs.esp = ((STACK_ADDR & 0x0000f) + STACK_SIZE); -+ -+ /* These will be fetched off the stack when we come to an iret in the -+ * int's 0x10 code. */ -+ VM86_PUSHW(DEFAULT_VM86_FLAGS); -+ VM86_PUSHW((RET_CODE_ADDR >> 4)); /* return code segment */ -+ VM86_PUSHW((RET_CODE_ADDR & 0x0000f)); /* return code offset */ -+ -+ while(1) { -+ ret = vm86old(&vm86); -+ -+ if (VM86_TYPE(ret) == VM86_INTx) { -+ int vint = VM86_ARG(ret); -+ -+ /* If exit from vm86 was caused by int 0xff, then -+ * we're done.. */ -+ if (vint == 0xff) -+ goto out; -+ -+ /* .. otherwise, we have to call the int handler -+ * manually */ -+ VM86_PUSHW(vm86.regs.eflags); -+ VM86_PUSHW(vm86.regs.cs); -+ VM86_PUSHW(vm86.regs.eip); -+ -+ vm86.regs.cs = *(u16 *)((vint << 2) + 2); -+ vm86.regs.eip = *(u16 *)(vint << 2); -+ vm86.regs.eflags &= ~(VIF_MASK | TF_MASK); -+ } else if (VM86_TYPE(ret) == VM86_UNKNOWN) { -+ if (vm86_do_unknown()) -+ goto out; -+ } else { -+ printk(KERN_ERR "vesafb: BUG, returned from " -+ "vm86 with %x (EIP: 0x%lx)\n", -+ ret, (u32)(vm86.regs.cs << 4) + -+ vm86.regs.eip); -+ goto out; -+ } -+ } -+ -+out: /* copy the registers' state back to the caller's struct */ -+ memcpy(regs, &vm86.regs, sizeof(struct vm86_regs)); -+} -+ -+static int vesafb_remap_pfn_range(unsigned long start, unsigned long end, -+ unsigned long pgoff, unsigned long prot, -+ int type) -+{ -+ struct vm_area_struct *vma; -+ struct mm_struct *mm = current->mm; -+ int ret = 0; -+ -+ vma = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL); -+ if (!vma) -+ return -ENOMEM; -+ memset(vma, 0, sizeof(*vma)); -+ down_write(&mm->mmap_sem); -+ vma->vm_mm = mm; -+ vma->vm_start = start; -+ vma->vm_end = end; -+ vma->vm_flags = VM_READ | VM_WRITE | VM_EXEC; -+ vma->vm_flags |= mm->def_flags; -+ vma->vm_page_prot.pgprot = prot; -+ vma->vm_pgoff = pgoff; -+ -+ if ((ret = insert_vm_struct(mm, vma))) { -+ up_write(&mm->mmap_sem); -+ kmem_cache_free(vm_area_cachep, vma); -+ return ret; -+ } -+ -+ if (type) { -+ ret = zeromap_page_range(vma, -+ vma->vm_start, -+ vma->vm_end - vma->vm_start, -+ vma->vm_page_prot); -+ } else { -+ vma->vm_flags |= VM_SHARED; -+ ret = remap_pfn_range(vma, -+ vma->vm_start, -+ vma->vm_pgoff, -+ vma->vm_end - vma->vm_start, -+ vma->vm_page_prot); -+ } -+ up_write(&mm->mmap_sem); -+ return ret; -+} -+ -+static inline int vesafb_init_mem(void) -+{ -+ int ret = 0; -+ -+ /* The memory chunks we're remapping here should be multiples -+ * of PAGE_SIZE. */ -+ ret += vesafb_remap_pfn_range(0x00000, IVTBDA_SIZE, 0, -+ PROT_READ | PROT_EXEC | PROT_WRITE, 0); -+ ret += vesafb_remap_pfn_range(IVTBDA_SIZE, REAL_MEM_SIZE, 0, -+ PROT_READ | PROT_EXEC | PROT_WRITE, 1); -+ ret += vesafb_remap_pfn_range(0x9f000, 0x100000, -+ 0x9f000 >> PAGE_SHIFT, -+ PROT_READ | PROT_EXEC | PROT_WRITE, 0); -+ if (ret) -+ printk(KERN_ERR "vesafb thread: memory remapping failed\n"); -+ -+ return ret; -+} -+ -+#define vesafb_get_string(str) \ -+{ \ -+ /* The address is in the form ssssoooo, where oooo = offset, \ -+ * ssss = segment */ \ -+ addr = ((p_vbe(tsk->buf)->str & 0xffff0000) >> 12) + \ -+ (p_vbe(tsk->buf)->str & 0x0000ffff); \ -+ \ -+ /* The data is in ROM which is shared between processes, so we \ -+ * just translate the real mode address into one visible from \ -+ * kernel space */ \ -+ if (addr >= 0xa0000) { \ -+ p_vbe(tsk->buf)->str = (u32) __va(addr); \ -+ \ -+ /* The data is in the buffer, we just have to convert the \ -+ * address so that it points into the buffer user provided. */ \ -+ } else if (addr > BUF_ADDR && addr < BUF_ADDR + \ -+ sizeof(struct vesafb_vbe_ib)) { \ -+ addr -= BUF_ADDR; \ -+ p_vbe(tsk->buf)->str = (u32) (tsk->buf + addr); \ -+ \ -+ /* This should never happen: someone was insane enough to put \ -+ * the data somewhere in RAM.. */ \ -+ } else { \ -+ p_vbe(tsk->buf)->str = (u32) ""; \ -+ } \ -+} -+ -+void vesafb_handle_getvbeib(struct vesafb_task *tsk) -+{ -+ int addr, res; -+ -+ tsk->regs.es = (BUF_ADDR >> 4); -+ tsk->regs.edi = (BUF_ADDR & 0x000f); -+ strncpy(p_vbe(BUF_ADDR)->vbe_signature, "VBE2", 4); -+ -+ vesafb_do_vm86(&tsk->regs); -+ memcpy(tsk->buf, (void*)(BUF_ADDR), sizeof(struct vesafb_vbe_ib)); -+ -+ /* The OEM fields were not defined prior to VBE 2.0 */ -+ if (p_vbe(tsk->buf)->vbe_version >= 0x200) { -+ vesafb_get_string(oem_string_ptr); -+ vesafb_get_string(oem_vendor_name_ptr); -+ vesafb_get_string(oem_product_name_ptr); -+ vesafb_get_string(oem_product_rev_ptr); -+ } -+ -+ /* This is basically the same as vesafb_get_string() */ -+ addr = ((p_vbe(tsk->buf)->mode_list_ptr & 0xffff0000) >> 12) + -+ (p_vbe(tsk->buf)->mode_list_ptr & 0x0000ffff); -+ -+ if (addr >= 0xa0000) { -+ p_vbe(tsk->buf)->mode_list_ptr = (u32) __va(addr); -+ } else if (addr > BUF_ADDR && addr < BUF_ADDR + -+ sizeof(struct vesafb_vbe_ib)) { -+ addr -= BUF_ADDR; -+ p_vbe(tsk->buf)->mode_list_ptr = (u32) (tsk->buf + addr); -+ } else { -+ res = 0; -+ printk(KERN_WARNING "vesafb: warning, copying modelist " -+ "from somewhere in RAM!\n"); -+ while (*(u16*)(addr+res) != 0xffff && -+ res < (sizeof(p_vbe(tsk->buf)->reserved) - 2)) { -+ *(u16*) ((u32)&(p_vbe(tsk->buf)->reserved) + res) = -+ *(u16*)(addr+res); -+ res += 2; -+ } -+ *(u16*) ((u32)&(p_vbe(tsk->buf)->reserved) + res) = 0xffff; -+ } -+} -+ -+int vesafb_handle_tasks(void) -+{ -+ struct vesafb_task *tsk; -+ struct list_head *curr, *next; -+ int ret = 0; -+ -+ down(&vesafb_task_list_sem); -+ list_for_each_safe(curr, next, &vesafb_task_list) { -+ tsk = list_entry(curr, struct vesafb_task, node); -+ -+ if (tsk->flags & TF_EXIT) { -+ ret = 1; -+ goto task_done; -+ } -+ if (tsk->flags & TF_GETVBEIB) { -+ vesafb_handle_getvbeib(tsk); -+ goto task_done; -+ } -+ /* Do we need to store a pointer to the buffer in ES:EDI? */ -+ if (tsk->flags & TF_BUF_DI) { -+ tsk->regs.es = (BUF_ADDR >> 4); -+ tsk->regs.edi = (BUF_ADDR & 0x000f); -+ } -+ /* Sometimes the pointer has to be in ES:EBX. */ -+ if (tsk->flags & TF_BUF_BX) { -+ tsk->regs.es = (BUF_ADDR >> 4); -+ tsk->regs.ebx = (BUF_ADDR & 0x000f); -+ } -+ if (tsk->flags & (TF_BUF_DI | TF_BUF_BX)) -+ memcpy((void*)BUF_ADDR, tsk->buf, tsk->buf_len); -+ -+ vesafb_do_vm86(&tsk->regs); -+ -+ if (tsk->flags & TF_RETURN_BUF) -+ memcpy(tsk->buf, (void*)BUF_ADDR, tsk->buf_len); -+ -+task_done: list_del(curr); -+ complete(&tsk->done); -+ } -+ -+ /* If we're going to kill this thread, don't allow any elements -+ * to be added to the task list. */ -+ if (!ret) -+ up(&vesafb_task_list_sem); -+ -+ return ret; -+} -+ -+/* -+ * This 'hybrid' thread serves as a backend for vesafb-tng, handling all vm86 -+ * calls. It is started as a kernel thread. It then creates its own mm struct, -+ * thus separating itself from any userspace processes. At this moment, it -+ * stops being a kernel thread (kernel threads have mm = NULL) and becomes -+ * a 'hybrid' thread -- one that has full access to kernel space, yet runs -+ * with its own address space. -+ * -+ * This is necessary because in order to make vm86 calls some parts of the -+ * first 1MB of RAM have to be setup to mimic the real mode. These are: -+ * - interrupt vector table [0x00000-0x003ff] -+ * - BIOS data area [0x00400-0x004ff] -+ * - Extended BIOS data area [0x9fc00-0x9ffff] -+ * - the video RAM [0xa0000-0xbffff] -+ * - video BIOS [0xc0000-0xcffff] -+ * - motherboard BIOS [0xf0000-0xfffff] -+ */ -+int vesafb_thread(void *unused) -+{ -+ int err = 0; -+ -+ set_fs(KERNEL_DS); -+ daemonize("vesafb"); -+ -+ if (set_new_mm()) { -+ err = -ENOMEM; -+ goto thr_end; -+ } -+ if (vesafb_init_mem()) { -+ err = -ENOMEM; -+ goto thr_end; -+ } -+ -+ DPRINTK("started vesafb thread\n"); -+ -+ /* Having an IO bitmap makes things faster as we avoid GPFs -+ * when running vm86 code. We can live if it fails, though, -+ * so don't bother checking for errors. */ -+ ioperm(0,1024,1); -+ set_user_nice(current, -10); -+ -+ complete(&vesafb_th_completion); -+ -+ while (1) { -+ if (vesafb_handle_tasks()) -+ break; -+ wait_event_interruptible(vesafb_wait, -+ !list_empty(&vesafb_task_list)); -+ try_to_freeze(); -+ } -+ -+out: DPRINTK("exiting the vesafb thread\n"); -+ vesafb_pid = -1; -+ -+ /* Now that all callers know this thread is no longer running -+ * (pid < 0), allow them to continue. */ -+ up(&vesafb_task_list_sem); -+ return err; -+thr_end: -+ down(&vesafb_task_list_sem); -+ complete(&vesafb_th_completion); -+ goto out; -+} -+ -+int vesafb_queue_task(struct vesafb_task *tsk) -+{ -+ down(&vesafb_task_list_sem); -+ if (vesafb_pid < 0) -+ return -1; -+ list_add_tail(&tsk->node, &vesafb_task_list); -+ up(&vesafb_task_list_sem); -+ wake_up(&vesafb_wait); -+ return 0; -+} -+ -+int vesafb_wait_for_thread(void) -+{ -+ /* PID 0 means that the thread is still initializing. */ -+ if (vesafb_pid < 0) -+ return -1; -+ wait_for_completion(&vesafb_th_completion); -+ return 0; -+} -+ -+int __init vesafb_init_thread(void) -+{ -+ vesafb_pid = kernel_thread(vesafb_thread,NULL,0); -+ return 0; -+} -+ -+#ifdef MODULE -+void __exit vesafb_kill_thread(void) -+{ -+ struct vesafb_task *tsk; -+ if (vesafb_pid <= 0) -+ return; -+ -+ vesafb_create_task(tsk); -+ if (!tsk) -+ return; -+ tsk->flags |= TF_EXIT; -+ vesafb_queue_task(tsk); -+ vesafb_wait_for_task(tsk); -+ kfree(tsk); -+ return; -+} -+module_exit(vesafb_kill_thread); -+#endif -+module_init(vesafb_init_thread); -+ -+EXPORT_SYMBOL_GPL(vesafb_queue_task); -+EXPORT_SYMBOL_GPL(vesafb_wait_for_thread); -+ -+MODULE_LICENSE("GPL"); -+MODULE_AUTHOR("Michal Januszewski"); -+ -diff --git a/drivers/video/vesafb-tng.c b/drivers/video/vesafb-tng.c -new file mode 100644 -index 0000000..b4d4394 ---- /dev/null -+++ b/drivers/video/vesafb-tng.c -@@ -0,0 +1,1586 @@ -+/* -+ * Framebuffer driver for VBE 2.0+ compliant graphic boards -+ * -+ * (c) 2004-2006 Michal Januszewski <spock@gentoo.org> -+ * Based upon vesafb code by Gerd Knorr <kraxel@goldbach.in-berlin.de> -+ * -+ */ -+ -+#include <linux/module.h> -+#include <linux/kernel.h> -+#include <linux/errno.h> -+#include <linux/string.h> -+#include <linux/mm.h> -+#include <linux/tty.h> -+#include <linux/delay.h> -+#include <linux/fb.h> -+#include <linux/ioport.h> -+#include <linux/init.h> -+#include <linux/proc_fs.h> -+#include <linux/completion.h> -+#include <linux/platform_device.h> -+#include <video/edid.h> -+#include <video/vesa.h> -+#include <video/vga.h> -+#include <asm/io.h> -+#include <asm/mtrr.h> -+#include <asm/page.h> -+#include <asm/pgtable.h> -+#include "edid.h" -+ -+#define dac_reg (0x3c8) -+#define dac_val (0x3c9) -+ -+#define VESAFB_NEED_EXACT_RES 1 -+#define VESAFB_NEED_EXACT_DEPTH 2 -+ -+/* --------------------------------------------------------------------- */ -+ -+static struct fb_var_screeninfo vesafb_defined __initdata = { -+ .activate = FB_ACTIVATE_NOW, -+ .height = 0, -+ .width = 0, -+ .right_margin = 32, -+ .upper_margin = 16, -+ .lower_margin = 4, -+ .vsync_len = 4, -+ .vmode = FB_VMODE_NONINTERLACED, -+}; -+ -+static struct fb_fix_screeninfo vesafb_fix __initdata = { -+ .id = "VESA VGA", -+ .type = FB_TYPE_PACKED_PIXELS, -+ .accel = FB_ACCEL_NONE, -+}; -+ -+static int mtrr = 0; /* disable mtrr by default */ -+static int blank = 1; /* enable blanking by default */ -+static int ypan = 0; /* 0 - nothing, 1 - ypan, 2 - ywrap */ -+static int pmi_setpal = 1; /* pmi for palette changes */ -+static u16 *pmi_base = NULL; /* protected mode interface location */ -+static void (*pmi_start)(void) = NULL; -+static void (*pmi_pal)(void) = NULL; -+static struct vesafb_vbe_ib vbe_ib; -+static struct vesafb_mode_ib *vbe_modes; -+static int vbe_modes_cnt = 0; -+static struct fb_info *vesafb_info = NULL; -+static int nocrtc = 0; /* ignore CRTC settings */ -+static int noedid __initdata = 0; /* don't try DDC transfers */ -+static int vram_remap __initdata = 0; /* set amount of memory to be used */ -+static int vram_total __initdata = 0; /* set total amount of memory */ -+static u16 maxclk __initdata = 0; /* maximum pixel clock */ -+static u16 maxvf __initdata = 0; /* maximum vertical frequency */ -+static u16 maxhf __initdata = 0; /* maximum horizontal frequency */ -+static int gtf __initdata = 0; /* forces use of the GTF */ -+static char *mode_option __initdata = NULL; -+static u16 vbemode __initdata = 0; -+ -+/* --------------------------------------------------------------------- */ -+ -+static int vesafb_find_vbe_mode(int xres, int yres, int depth, -+ unsigned char flags) -+{ -+ int i, match = -1, h = 0, d = 0x7fffffff; -+ -+ for (i = 0; i < vbe_modes_cnt; i++) { -+ h = abs(vbe_modes[i].x_res - xres) + -+ abs(vbe_modes[i].y_res - yres) + -+ abs(depth - vbe_modes[i].depth); -+ if (h == 0) -+ return i; -+ if (h < d || (h == d && vbe_modes[i].depth > depth)) { -+ d = h; -+ match = i; -+ } -+ } -+ i = 1; -+ -+ if (flags & VESAFB_NEED_EXACT_DEPTH && vbe_modes[match].depth != depth) -+ i = 0; -+ if (flags & VESAFB_NEED_EXACT_RES && d > 24) -+ i = 0; -+ if (i != 0) -+ return match; -+ else -+ return -1; -+} -+ -+static int vesafb_pan_display(struct fb_var_screeninfo *var, -+ struct fb_info *info) -+{ -+ int offset; -+ -+ offset = (var->yoffset * info->fix.line_length + var->xoffset) / 4; -+ -+ /* It turns out it's not the best idea to do panning via vm86, -+ * so we only allow it if we have a PMI. */ -+ if (pmi_start) { -+ __asm__ __volatile__( -+ "call *(%%edi)" -+ : /* no return value */ -+ : "a" (0x4f07), /* EAX */ -+ "b" (0), /* EBX */ -+ "c" (offset), /* ECX */ -+ "d" (offset >> 16), /* EDX */ -+ "D" (&pmi_start)); /* EDI */ -+ } -+ return 0; -+} -+ -+static int vesafb_blank(int blank, struct fb_info *info) -+{ -+ struct vesafb_task *tsk; -+ int err = 1; -+ -+ if (vbe_ib.capabilities & VBE_CAP_VGACOMPAT) { -+ int loop = 10000; -+ u8 seq = 0, crtc17 = 0; -+ -+ if (blank == FB_BLANK_POWERDOWN) { -+ seq = 0x20; -+ crtc17 = 0x00; -+ err = 0; -+ } else { -+ seq = 0x00; -+ crtc17 = 0x80; -+ err = (blank == FB_BLANK_UNBLANK) ? 0 : -EINVAL; -+ } -+ -+ vga_wseq(NULL, 0x00, 0x01); -+ seq |= vga_rseq(NULL, 0x01) & ~0x20; -+ vga_wseq(NULL, 0x00, seq); -+ -+ crtc17 |= vga_rcrt(NULL, 0x17) & ~0x80; -+ while (loop--); -+ vga_wcrt(NULL, 0x17, crtc17); -+ vga_wseq(NULL, 0x00, 0x03); -+ } else { -+ vesafb_create_task (tsk); -+ if (!tsk) -+ return -ENOMEM; -+ tsk->regs.eax = 0x4f10; -+ switch (blank) { -+ case FB_BLANK_UNBLANK: -+ tsk->regs.ebx = 0x0001; -+ break; -+ case FB_BLANK_NORMAL: -+ tsk->regs.ebx = 0x0101; /* standby */ -+ break; -+ case FB_BLANK_POWERDOWN: -+ tsk->regs.ebx = 0x0401; /* powerdown */ -+ break; -+ default: -+ goto out; -+ } -+ tsk->flags = TF_CALL; -+ if (!vesafb_queue_task (tsk)) -+ vesafb_wait_for_task(tsk); -+ -+ if ((tsk->regs.eax & 0xffff) == 0x004f) -+ err = 0; -+out: kfree(tsk); -+ } -+ return err; -+} -+ -+static int vesafb_setpalette(struct vesafb_pal_entry *entries, int count, -+ int start, struct fb_info *info) -+{ -+ struct vesafb_task *tsk; -+ int i = ((struct vesafb_par*)info->par)->mode_idx; -+ int ret = 0; -+ -+ /* We support palette modifications for 8 bpp modes only, so -+ * there can never be more than 256 entries. */ -+ if (start + count > 256) -+ return -EINVAL; -+ -+ /* Use VGA registers if mode is VGA-compatible. */ -+ if (i >= 0 && i < vbe_modes_cnt && -+ vbe_modes[i].mode_attr & VBE_MODE_VGACOMPAT) { -+ for (i = 0; i < count; i++) { -+ outb_p(start + i, dac_reg); -+ outb_p(entries[i].red, dac_val); -+ outb_p(entries[i].green, dac_val); -+ outb_p(entries[i].blue, dac_val); -+ } -+ } else if (pmi_setpal) { -+ __asm__ __volatile__( -+ "call *(%%esi)" -+ : /* no return value */ -+ : "a" (0x4f09), /* EAX */ -+ "b" (0), /* EBX */ -+ "c" (count), /* ECX */ -+ "d" (start), /* EDX */ -+ "D" (entries), /* EDI */ -+ "S" (&pmi_pal)); /* ESI */ -+ } else { -+ vesafb_create_task (tsk); -+ if (!tsk) -+ return -ENOMEM; -+ tsk->regs.eax = 0x4f09; -+ tsk->regs.ebx = 0x0; -+ tsk->regs.ecx = count; -+ tsk->regs.edx = start; -+ tsk->buf = entries; -+ tsk->buf_len = sizeof(struct vesafb_pal_entry) * count; -+ tsk->flags = TF_CALL | TF_BUF_DI; -+ -+ if (!vesafb_queue_task (tsk)) -+ vesafb_wait_for_task(tsk); -+ if ((tsk->regs.eax & 0xffff) != 0x004f) -+ ret = 1; -+ kfree(tsk); -+ } -+ return ret; -+} -+ -+static int vesafb_setcolreg(unsigned regno, unsigned red, unsigned green, -+ unsigned blue, unsigned transp, -+ struct fb_info *info) -+{ -+ struct vesafb_pal_entry entry; -+ int shift = 16 - info->var.green.length; -+ int ret = 0; -+ -+ if (regno >= info->cmap.len) -+ return -EINVAL; -+ -+ if (info->var.bits_per_pixel == 8) { -+ entry.red = red >> shift; -+ entry.green = green >> shift; -+ entry.blue = blue >> shift; -+ entry.pad = 0; -+ -+ ret = vesafb_setpalette(&entry, 1, regno, info); -+ } else if (regno < 16) { -+ switch (info->var.bits_per_pixel) { -+ case 16: -+ if (info->var.red.offset == 10) { -+ /* 1:5:5:5 */ -+ ((u32*) (info->pseudo_palette))[regno] = -+ ((red & 0xf800) >> 1) | -+ ((green & 0xf800) >> 6) | -+ ((blue & 0xf800) >> 11); -+ } else { -+ /* 0:5:6:5 */ -+ ((u32*) (info->pseudo_palette))[regno] = -+ ((red & 0xf800) ) | -+ ((green & 0xfc00) >> 5) | -+ ((blue & 0xf800) >> 11); -+ } -+ break; -+ -+ case 24: -+ case 32: -+ red >>= 8; -+ green >>= 8; -+ blue >>= 8; -+ ((u32 *)(info->pseudo_palette))[regno] = -+ (red << info->var.red.offset) | -+ (green << info->var.green.offset) | -+ (blue << info->var.blue.offset); -+ break; -+ } -+ } -+ return ret; -+} -+ -+static int vesafb_setcmap(struct fb_cmap *cmap, struct fb_info *info) -+{ -+ struct vesafb_pal_entry *entries; -+ int shift = 16 - info->var.green.length; -+ int i, ret = 0; -+ -+ if (info->var.bits_per_pixel == 8) { -+ if (cmap->start + cmap->len > info->cmap.start + -+ info->cmap.len || cmap->start < info->cmap.start) -+ return -EINVAL; -+ -+ entries = vmalloc(sizeof(struct vesafb_pal_entry) * cmap->len); -+ if (!entries) -+ return -ENOMEM; -+ for (i = 0; i < cmap->len; i++) { -+ entries[i].red = cmap->red[i] >> shift; -+ entries[i].green = cmap->green[i] >> shift; -+ entries[i].blue = cmap->blue[i] >> shift; -+ entries[i].pad = 0; -+ } -+ ret = vesafb_setpalette(entries, cmap->len, cmap->start, info); -+ vfree(entries); -+ } else { -+ /* For modes with bpp > 8, we only set the pseudo palette in -+ * the fb_info struct. We rely on vesafb_setcolreg to do all -+ * sanity checking. */ -+ for (i = 0; i < cmap->len; i++) { -+ ret += vesafb_setcolreg(cmap->start + i, cmap->red[i], -+ cmap->green[i], cmap->blue[i], -+ 0, info); -+ } -+ } -+ return ret; -+} -+ -+static int vesafb_set_par(struct fb_info *info) -+{ -+ struct vesafb_par *par = (struct vesafb_par *) info->par; -+ struct vesafb_task *tsk; -+ struct vesafb_crtc_ib *crtc = NULL; -+ struct vesafb_mode_ib *mode = NULL; -+ int i, err = 0, depth = info->var.bits_per_pixel; -+ -+ if (depth > 8 && depth != 32) -+ depth = info->var.red.length + info->var.green.length + -+ info->var.blue.length; -+ -+ i = vesafb_find_vbe_mode(info->var.xres, info->var.yres, depth, -+ VESAFB_NEED_EXACT_RES | -+ VESAFB_NEED_EXACT_DEPTH); -+ if (i >= 0) -+ mode = &vbe_modes[i]; -+ else -+ return -EINVAL; -+ -+ vesafb_create_task (tsk); -+ if (!tsk) -+ return -ENOMEM; -+ tsk->regs.eax = 0x4f02; -+ tsk->regs.ebx = mode->mode_id | 0x4000; /* use LFB */ -+ tsk->flags = TF_CALL; -+ -+ if (vbe_ib.vbe_version >= 0x0300 && !nocrtc && -+ info->var.pixclock != 0) { -+ tsk->regs.ebx |= 0x0800; /* use CRTC data */ -+ tsk->flags |= TF_BUF_DI; -+ crtc = kmalloc(sizeof(struct vesafb_crtc_ib), GFP_KERNEL); -+ if (!crtc) { -+ err = -ENOMEM; -+ goto out; -+ } -+ crtc->horiz_start = info->var.xres + info->var.right_margin; -+ crtc->horiz_end = crtc->horiz_start + info->var.hsync_len; -+ crtc->horiz_total = crtc->horiz_end + info->var.left_margin; -+ -+ crtc->vert_start = info->var.yres + info->var.lower_margin; -+ crtc->vert_end = crtc->vert_start + info->var.vsync_len; -+ crtc->vert_total = crtc->vert_end + info->var.upper_margin; -+ -+ crtc->pixel_clock = PICOS2KHZ(info->var.pixclock) * 1000; -+ crtc->refresh_rate = (u16)(100 * (crtc->pixel_clock / -+ (crtc->vert_total * crtc->horiz_total))); -+ crtc->flags = 0; -+ -+ if (info->var.vmode & FB_VMODE_DOUBLE) -+ crtc->flags |= 0x1; -+ if (info->var.vmode & FB_VMODE_INTERLACED) -+ crtc->flags |= 0x2; -+ if (!(info->var.sync & FB_SYNC_HOR_HIGH_ACT)) -+ crtc->flags |= 0x4; -+ if (!(info->var.sync & FB_SYNC_VERT_HIGH_ACT)) -+ crtc->flags |= 0x8; -+ memcpy(&par->crtc, crtc, sizeof(struct vesafb_crtc_ib)); -+ } else -+ memset(&par->crtc, 0, sizeof(struct vesafb_crtc_ib)); -+ -+ tsk->buf = (void*)crtc; -+ tsk->buf_len = sizeof(struct vesafb_crtc_ib); -+ -+ if (vesafb_queue_task (tsk)) { -+ err = -EINVAL; -+ goto out; -+ } -+ vesafb_wait_for_task(tsk); -+ -+ if ((tsk->regs.eax & 0xffff) != 0x004f) { -+ printk(KERN_ERR "vesafb: mode switch failed (eax: 0x%lx)\n", -+ tsk->regs.eax); -+ err = -EINVAL; -+ goto out; -+ } -+ par->mode_idx = i; -+ -+ /* For 8bpp modes, always try to set the DAC to 8 bits. */ -+ if (vbe_ib.capabilities & VBE_CAP_CAN_SWITCH_DAC && -+ mode->bits_per_pixel <= 8) { -+ vesafb_reset_task(tsk); -+ tsk->flags = TF_CALL; -+ tsk->regs.eax = 0x4f08; -+ tsk->regs.ebx = 0x0800; -+ -+ if (!vesafb_queue_task (tsk)) -+ vesafb_wait_for_task(tsk); -+ -+ if ((tsk->regs.eax & 0xffff) != 0x004f || -+ ((tsk->regs.ebx & 0xff00) >> 8) != 8) { -+ /* We've failed to set the DAC palette format - -+ * time to correct var. */ -+ info->var.red.length = 6; -+ info->var.green.length = 6; -+ info->var.blue.length = 6; -+ } -+ } -+ -+ info->fix.visual = (info->var.bits_per_pixel == 8) ? -+ FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR; -+ info->fix.line_length = mode->bytes_per_scan_line; -+ -+ DPRINTK("set new mode %dx%d-%d (0x%x)\n", -+ info->var.xres, info->var.yres, info->var.bits_per_pixel, -+ mode->mode_id); -+ -+out: if (crtc != NULL) -+ kfree(crtc); -+ kfree(tsk); -+ -+ return err; -+} -+ -+static void vesafb_setup_var(struct fb_var_screeninfo *var, struct fb_info *info, -+ struct vesafb_mode_ib *mode) -+{ -+ var->xres = mode->x_res; -+ var->yres = mode->y_res; -+ var->xres_virtual = mode->x_res; -+ var->yres_virtual = (ypan) ? -+ info->fix.smem_len / mode->bytes_per_scan_line : -+ mode->y_res; -+ var->xoffset = 0; -+ var->yoffset = 0; -+ var->bits_per_pixel = mode->bits_per_pixel; -+ -+ if (var->bits_per_pixel == 15) -+ var->bits_per_pixel = 16; -+ -+ if (var->bits_per_pixel > 8) { -+ var->red.offset = mode->red_off; -+ var->red.length = mode->red_len; -+ var->green.offset = mode->green_off; -+ var->green.length = mode->green_len; -+ var->blue.offset = mode->blue_off; -+ var->blue.length = mode->blue_len; -+ var->transp.offset = mode->rsvd_off; -+ var->transp.length = mode->rsvd_len; -+ -+ DPRINTK("directcolor: size=%d:%d:%d:%d, shift=%d:%d:%d:%d\n", -+ mode->rsvd_len, -+ mode->red_len, -+ mode->green_len, -+ mode->blue_len, -+ mode->rsvd_off, -+ mode->red_off, -+ mode->green_off, -+ mode->blue_off); -+ } else { -+ var->red.offset = 0; -+ var->green.offset = 0; -+ var->blue.offset = 0; -+ var->transp.offset = 0; -+ -+ /* We're assuming that we can switch the DAC to 8 bits. If -+ * this proves to be incorrect, we'll update the fields -+ * later in set_par(). */ -+ if (vbe_ib.capabilities & VBE_CAP_CAN_SWITCH_DAC) { -+ var->red.length = 8; -+ var->green.length = 8; -+ var->blue.length = 8; -+ var->transp.length = 0; -+ } else { -+ var->red.length = 6; -+ var->green.length = 6; -+ var->blue.length = 6; -+ var->transp.length = 0; -+ } -+ } -+} -+ -+static void inline vesafb_check_limits(struct fb_var_screeninfo *var, -+ struct fb_info *info) -+{ -+ struct fb_videomode *mode; -+ -+ if (!var->pixclock) -+ return; -+ if (vbe_ib.vbe_version < 0x0300) { -+ fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, 60, var, info); -+ return; -+ } -+ if (!fb_validate_mode(var, info)) -+ return; -+ mode = fb_find_best_mode(var, &info->modelist); -+ if (mode) { -+ DPRINTK("find_best_mode: %d %d @ %d (vmode: %d)\n", -+ mode->xres, mode->yres, mode->refresh, mode->vmode); -+ if (mode->xres == var->xres && mode->yres == var->yres && -+ !(mode->vmode & (FB_VMODE_INTERLACED | FB_VMODE_DOUBLE))) { -+ fb_videomode_to_var(var, mode); -+ return; -+ } -+ } -+ if (info->monspecs.gtf && !fb_get_mode(FB_MAXTIMINGS, 0, var, info)) -+ return; -+ /* Use default refresh rate */ -+ var->pixclock = 0; -+} -+ -+static int vesafb_check_var(struct fb_var_screeninfo *var, -+ struct fb_info *info) -+{ -+ int match = -1; -+ int depth = var->red.length + var->green.length + var->blue.length; -+ -+ /* Various apps will use bits_per_pixel to set the color depth, -+ * which is theoretically incorrect, but which we'll try to handle -+ * here. */ -+ if (depth == 0 || abs(depth - var->bits_per_pixel) >= 8) -+ depth = var->bits_per_pixel; -+ match = vesafb_find_vbe_mode(var->xres, var->yres, depth, -+ VESAFB_NEED_EXACT_RES); -+ -+ if (match == -1) { -+ DPRINTK("vesafb: mode %dx%d-%d not found\n", var->xres, -+ var->yres, depth); -+ return -EINVAL; -+ } -+ -+ vesafb_setup_var(var, info, &vbe_modes[match]); -+ DPRINTK("found mode 0x%x (%dx%d-%dbpp)\n", -+ vbe_modes[match].mode_id, vbe_modes[match].x_res, -+ vbe_modes[match].y_res, vbe_modes[match].depth); -+ -+ /* Check whether we have remapped enough memory for this mode. */ -+ if (var->yres * vbe_modes[match].bytes_per_scan_line > -+ info->fix.smem_len) { -+ return -EINVAL; -+ } -+ -+ if ((var->vmode & FB_VMODE_DOUBLE) && -+ !(vbe_modes[match].mode_attr & 0x100)) -+ var->vmode &= ~FB_VMODE_DOUBLE; -+ if ((var->vmode & FB_VMODE_INTERLACED) && -+ !(vbe_modes[match].mode_attr & 0x200)) -+ var->vmode &= ~FB_VMODE_INTERLACED; -+ vesafb_check_limits(var, info); -+ return 0; -+} -+ -+static int vesafb_open(struct fb_info *info, int user) -+{ -+ struct vesafb_task *tsk = NULL; -+ struct vesafb_par *par = info->par; -+ int cnt = atomic_read(&par->ref_count); -+ -+ if (!cnt) { -+ vesafb_create_task(tsk); -+ if (!tsk) -+ goto out; -+ -+ /* Get the VBE state buffer size. We want all available -+ * hardware state data (CL = 0x0f). */ -+ tsk->regs.eax = 0x4f04; -+ tsk->regs.ecx = 0x000f; -+ tsk->regs.edx = 0x0000; -+ tsk->flags = TF_CALL; -+ -+ if (vesafb_queue_task(tsk)) -+ goto out; -+ -+ vesafb_wait_for_task(tsk); -+ -+ if ((tsk->regs.eax & 0xffff) != 0x004f) { -+ printk(KERN_WARNING "vesafb: VBE state buffer size " -+ "cannot be determined (eax: 0x%lx)\n", -+ tsk->regs.eax); -+ goto out; -+ } -+ -+ par->vbe_state_size = 64 * (tsk->regs.ebx & 0xffff); -+ par->vbe_state = kzalloc(par->vbe_state_size, GFP_KERNEL); -+ if (!par->vbe_state) -+ goto out; -+ -+ vesafb_reset_task(tsk); -+ tsk->regs.eax = 0x4f04; -+ tsk->regs.ecx = 0x000f; -+ tsk->regs.edx = 0x0001; -+ tsk->flags = TF_CALL | TF_BUF_BX | TF_RETURN_BUF; -+ tsk->buf = (void*)(par->vbe_state); -+ tsk->buf_len = par->vbe_state_size; -+ -+ if (vesafb_queue_task(tsk)) -+ goto getstate_failed; -+ vesafb_wait_for_task(tsk); -+ -+ if ((tsk->regs.eax & 0xffff) != 0x004f) { -+ printk(KERN_WARNING "vesafb: VBE get state call " -+ "failed (eax: 0x%lx)\n", tsk->regs.eax); -+ goto getstate_failed; -+ } -+ } -+out: -+ atomic_inc(&par->ref_count); -+ if (tsk) -+ kfree(tsk); -+ return 0; -+ -+getstate_failed: -+ kfree(par->vbe_state); -+ par->vbe_state = NULL; -+ par->vbe_state_size = 0; -+ goto out; -+} -+ -+static int vesafb_release(struct fb_info *info, int user) -+{ -+ struct vesafb_task *tsk = NULL; -+ struct vesafb_par *par = info->par; -+ int cnt = atomic_read(&par->ref_count); -+ -+ if (!cnt) -+ return -EINVAL; -+ -+ if (cnt == 1 && par->vbe_state && par->vbe_state_size) { -+ vesafb_create_task(tsk); -+ if (!tsk) -+ goto out; -+ -+ tsk->regs.eax = 0x0003; -+ tsk->regs.ebx = 0x0000; -+ tsk->flags = TF_CALL; -+ -+ if (vesafb_queue_task(tsk)) -+ goto out; -+ -+ vesafb_wait_for_task(tsk); -+ -+ vesafb_reset_task(tsk); -+ tsk->regs.eax = 0x4f04; -+ tsk->regs.ecx = 0x000f; -+ tsk->regs.edx = 0x0002; -+ tsk->buf = (void*)(par->vbe_state); -+ tsk->buf_len = par->vbe_state_size; -+ tsk->flags = TF_CALL | TF_BUF_BX; -+ -+ if (vesafb_queue_task(tsk)) -+ goto out; -+ -+ vesafb_wait_for_task(tsk); -+ -+ if ((tsk->regs.eax & 0xffff) != 0x004f) -+ printk(KERN_WARNING "vesafb: VBE state restore call " -+ "failed (eax: 0x%lx)\n", -+ tsk->regs.eax); -+ } -+out: -+ atomic_dec(&par->ref_count); -+ if (tsk) -+ kfree(tsk); -+ return 0; -+} -+ -+static int __init vesafb_probe(struct platform_device *device); -+ -+static struct fb_ops vesafb_ops = { -+ .owner = THIS_MODULE, -+ .fb_open = vesafb_open, -+ .fb_release = vesafb_release, -+ .fb_setcolreg = vesafb_setcolreg, -+ .fb_setcmap = vesafb_setcmap, -+ .fb_pan_display = vesafb_pan_display, -+ .fb_blank = vesafb_blank, -+ .fb_fillrect = cfb_fillrect, -+ .fb_copyarea = cfb_copyarea, -+ .fb_imageblit = cfb_imageblit, -+ .fb_check_var = vesafb_check_var, -+ .fb_set_par = vesafb_set_par -+}; -+ -+static struct platform_driver vesafb_driver = { -+ .probe = vesafb_probe, -+ .driver = { -+ .name = "vesafb", -+ }, -+}; -+ -+static struct platform_device *vesafb_device; -+ -+#ifndef MODULE -+int __init vesafb_setup(char *options) -+{ -+ char *this_opt; -+ -+ if (!options || !*options) -+ return 0; -+ -+ DPRINTK("options %s\n",options); -+ -+ while ((this_opt = strsep(&options, ",")) != NULL) { -+ if (!*this_opt) continue; -+ -+ DPRINTK("this_opt: %s\n",this_opt); -+ -+ if (! strcmp(this_opt, "redraw")) -+ ypan=0; -+ else if (! strcmp(this_opt, "ypan")) -+ ypan=1; -+ else if (! strcmp(this_opt, "ywrap")) -+ ypan=2; -+ else if (! strcmp(this_opt, "vgapal")) -+ pmi_setpal=0; -+ else if (! strcmp(this_opt, "pmipal")) -+ pmi_setpal=1; -+ else if (! strncmp(this_opt, "mtrr:", 5)) -+ mtrr = simple_strtoul(this_opt+5, NULL, 0); -+ else if (! strcmp(this_opt, "nomtrr")) -+ mtrr=0; -+ else if (! strcmp(this_opt, "nocrtc")) -+ nocrtc=1; -+ else if (! strcmp(this_opt, "noedid")) -+ noedid=1; -+ else if (! strcmp(this_opt, "noblank")) -+ blank=0; -+ else if (! strcmp(this_opt, "gtf")) -+ gtf=1; -+ else if (! strncmp(this_opt, "vtotal:", 7)) -+ vram_total = simple_strtoul(this_opt + 7, NULL, 0); -+ else if (! strncmp(this_opt, "vremap:", 7)) -+ vram_remap = simple_strtoul(this_opt + 7, NULL, 0); -+ else if (! strncmp(this_opt, "maxhf:", 6)) -+ maxhf = simple_strtoul(this_opt + 6, NULL, 0); -+ else if (! strncmp(this_opt, "maxvf:", 6)) -+ maxvf = simple_strtoul(this_opt + 6, NULL, 0); -+ else if (! strncmp(this_opt, "maxclk:", 7)) -+ maxclk = simple_strtoul(this_opt + 7, NULL, 0); -+ else if (! strncmp(this_opt, "vbemode:", 8)) -+ vbemode = simple_strtoul(this_opt + 8, NULL,0); -+ else if (this_opt[0] >= '0' && this_opt[0] <= '9') { -+ DPRINTK("mode_option: %s\n",this_opt); -+ mode_option = this_opt; -+ } else { -+ printk(KERN_WARNING -+ "vesafb: unrecognized option %s\n", this_opt); -+ } -+ } -+ -+ return 0; -+} -+#endif /* !MODULE */ -+ -+static int vesafb_read_proc_modes(char *buf, char **start, off_t offset, -+ int len, int *eof, void *private) -+{ -+ int clen = 0, i; -+ -+ for (i = 0; i < vbe_modes_cnt; i++) { -+ clen += min(snprintf(buf + clen, len - clen, "%dx%d-%d\n", vbe_modes[i].x_res, -+ vbe_modes[i].y_res, vbe_modes[i].depth), len - clen); -+ } -+ *eof = 1; -+ return clen; -+} -+ -+static int vesafb_read_proc_vbe_info(char *buf, char **start, off_t offset, -+ int len, int *eof, void *private) -+{ -+ int clen = 0; -+ -+ clen += min(snprintf(buf + clen, len, "Version: %d.%d\n", -+ ((vbe_ib.vbe_version & 0xff00) >> 8), -+ vbe_ib.vbe_version & 0xff), len); -+ clen += min(snprintf(buf + clen, len - clen, "Vendor: %s\n", -+ (char*)vbe_ib.oem_vendor_name_ptr), len - clen); -+ clen += min(snprintf(buf + clen, len - clen, "Product: %s\n", -+ (char*)vbe_ib.oem_product_name_ptr), len - clen); -+ clen += min(snprintf(buf + clen, len - clen, "OEM rev: %s\n", -+ (char*)vbe_ib.oem_product_rev_ptr), len - clen); -+ clen += min(snprintf(buf + clen, len - clen, "OEM string: %s\n", -+ (char*)vbe_ib.oem_string_ptr), len - clen); -+ -+ *eof = 1; -+ return clen; -+} -+ -+static int __init inline vesafb_vbe_getinfo(struct vesafb_task *tsk) -+{ -+ tsk->regs.eax = 0x4f00; -+ tsk->flags = TF_CALL | TF_GETVBEIB; -+ tsk->buf = &vbe_ib; -+ tsk->buf_len = sizeof(vbe_ib); -+ if (vesafb_queue_task (tsk)) -+ return -EINVAL; -+ vesafb_wait_for_task(tsk); -+ -+ if (vbe_ib.vbe_version < 0x0200) { -+ printk(KERN_ERR "vesafb: Sorry, pre-VBE 2.0 cards are " -+ "not supported.\n"); -+ return -EINVAL; -+ } -+ -+ if ((tsk->regs.eax & 0xffff) != 0x004f) { -+ printk(KERN_ERR "vesafb: Getting mode info block failed " -+ "(eax=0x%x)\n", (u32)tsk->regs.eax); -+ return -EINVAL; -+ } -+ -+ printk(KERN_INFO "vesafb: %s, %s, %s (OEM: %s)\n", -+ (char*)vbe_ib.oem_vendor_name_ptr, -+ (char*)vbe_ib.oem_product_name_ptr, -+ (char*)vbe_ib.oem_product_rev_ptr, -+ (char*)vbe_ib.oem_string_ptr); -+ -+ printk(KERN_INFO "vesafb: VBE version: %d.%d\n", -+ ((vbe_ib.vbe_version & 0xff00) >> 8), -+ vbe_ib.vbe_version & 0xff); -+ return 0; -+} -+ -+static int __init inline vesafb_vbe_getmodes(struct vesafb_task *tsk) -+{ -+ u16 *mode = 0; -+ int off = 0; -+ -+ /* Count available modes. */ -+ mode = (u16*)vbe_ib.mode_list_ptr; -+ while (*mode != 0xffff) { -+ vbe_modes_cnt++; -+ mode++; -+ } -+ -+ vbe_modes = kmalloc(sizeof(struct vesafb_mode_ib)* -+ vbe_modes_cnt, GFP_KERNEL); -+ if (!vbe_modes) -+ return -ENOMEM; -+ -+ /* Get mode info for all available modes. */ -+ mode = (u16*)vbe_ib.mode_list_ptr; -+ -+ while (*mode != 0xffff) { -+ struct vesafb_mode_ib *mib; -+ -+ vesafb_reset_task(tsk); -+ tsk->regs.eax = 0x4f01; -+ tsk->regs.ecx = (u32) *mode; -+ tsk->flags = TF_CALL | TF_RETURN_BUF | TF_BUF_DI; -+ tsk->buf = vbe_modes+off; -+ tsk->buf_len = sizeof(struct vesafb_mode_ib); -+ if (vesafb_queue_task(tsk)) -+ return -EINVAL; -+ vesafb_wait_for_task(tsk); -+ mib = p_mode(tsk->buf); -+ mib->mode_id = *mode; -+ -+ /* We only want modes that are supported with the currennt -+ * hardware configuration (D0), color (D3), graphics (D4) -+ * and that have support for the LFB (D7). */ -+ if ((mib->mode_attr & 0x99) == 0x99 && -+ mib->bits_per_pixel >= 8) { -+ off++; -+ } else { -+ vbe_modes_cnt--; -+ } -+ mode++; -+ mib->depth = mib->red_len + mib->green_len + mib->blue_len; -+ /* Handle 8bpp modes and modes with broken color component -+ * lengths. */ -+ if (mib->depth == 0 || -+ (mib->depth == 24 && mib->bits_per_pixel == 32)) -+ mib->depth = mib->bits_per_pixel; -+ } -+ -+ return 0; -+} -+ -+static int __init inline vesafb_vbe_getpmi(struct vesafb_task *tsk) -+{ -+ int i; -+ -+ vesafb_reset_task(tsk); -+ tsk->regs.eax = 0x4f0a; -+ tsk->regs.ebx = 0x0; -+ tsk->flags = TF_CALL; -+ if (vesafb_queue_task(tsk)) -+ return -EINVAL; -+ vesafb_wait_for_task(tsk); -+ -+ if ((tsk->regs.eax & 0xffff) != 0x004f || tsk->regs.es < 0xc000) { -+ pmi_setpal = ypan = 0; -+ } else { -+ pmi_base = (u16*)phys_to_virt(((u32)tsk->regs.es << 4) + -+ tsk->regs.edi); -+ pmi_start = (void*)((char*)pmi_base + pmi_base[1]); -+ pmi_pal = (void*)((char*)pmi_base + pmi_base[2]); -+ printk(KERN_INFO "vesafb: protected mode interface info at " -+ "%04x:%04x\n", -+ (u16)tsk->regs.es, (u16)tsk->regs.edi); -+ printk(KERN_INFO "vesafb: pmi: set display start = %p, " -+ "set palette = %p\n", pmi_start, pmi_pal); -+ -+ if (pmi_base[3]) { -+ printk(KERN_INFO "vesafb: pmi: ports = "); -+ for (i = pmi_base[3]/2; pmi_base[i] != 0xffff; i++) -+ printk("%x ",pmi_base[i]); -+ printk("\n"); -+ -+ /* -+ * memory areas not supported (yet?) -+ * -+ * Rules are: we have to set up a descriptor for the -+ * requested memory area and pass it in the ES register -+ * to the BIOS function. -+ */ -+ if (pmi_base[i] != 0xffff) { -+ printk(KERN_INFO "vesafb: can't handle memory " -+ "requests, pmi disabled\n"); -+ ypan = pmi_setpal = 0; -+ } -+ } -+ } -+ return 0; -+} -+ -+static int __init inline vesafb_vbe_getedid(struct vesafb_task *tsk, -+ struct fb_info *info) -+{ -+ int res = 0; -+ -+ if (noedid || vbe_ib.vbe_version < 0x0300) -+ return -EINVAL; -+ -+ vesafb_reset_task(tsk); -+ tsk->regs.eax = 0x4f15; -+ tsk->regs.ebx = 0; -+ tsk->regs.ecx = 0; -+ if (vesafb_queue_task(tsk)) -+ return -EINVAL; -+ vesafb_wait_for_task(tsk); -+ -+ if ((tsk->regs.eax & 0xffff) != 0x004f) -+ return -EINVAL; -+ -+ if ((tsk->regs.ebx & 0x3) == 3) { -+ printk(KERN_INFO "vesafb: VBIOS/hardware supports both " -+ "DDC1 and DDC2 transfers\n"); -+ } else if ((tsk->regs.ebx & 0x3) == 2) { -+ printk(KERN_INFO "vesafb: VBIOS/hardware supports DDC2 " -+ "transfers\n"); -+ } else if ((tsk->regs.ebx & 0x3) == 1) { -+ printk(KERN_INFO "vesafb: VBIOS/hardware supports DDC1 " -+ "transfers\n"); -+ } else { -+ printk(KERN_INFO "vesafb: VBIOS/hardware doesn't support " -+ "DDC transfers\n"); -+ return -EINVAL; -+ } -+ -+ vesafb_reset_task(tsk); -+ tsk->regs.eax = 0x4f15; -+ tsk->regs.ebx = 1; -+ tsk->regs.ecx = tsk->regs.edx = 0; -+ tsk->flags = TF_CALL | TF_RETURN_BUF | TF_BUF_DI; -+ tsk->buf = kmalloc(EDID_LENGTH, GFP_KERNEL); -+ tsk->buf_len = EDID_LENGTH; -+ -+ if (vesafb_queue_task(tsk)) { -+ res = -EINVAL; -+ goto out; -+ } -+ vesafb_wait_for_task(tsk); -+ -+ if ((tsk->regs.eax & 0xffff) == 0x004f) { -+ fb_edid_to_monspecs(tsk->buf, &info->monspecs); -+ fb_videomode_to_modelist(info->monspecs.modedb, -+ info->monspecs.modedb_len, &info->modelist); -+ if (info->monspecs.vfmax && info->monspecs.hfmax) { -+ /* If the maximum pixel clock wasn't specified in -+ * the EDID block, set it to 300 MHz. */ -+ if (info->monspecs.dclkmax == 0) -+ info->monspecs.dclkmax = 300 * 1000000; -+ info->monspecs.gtf = 1; -+ } else { -+ res = -EINVAL; -+ } -+ } -+ -+out: kfree(tsk->buf); -+ return res; -+} -+ -+static void __init inline vesafb_vbe_getmonspecs(struct vesafb_task *tsk, -+ struct fb_info *info) -+{ -+ struct fb_var_screeninfo var; -+ int i; -+ memset(&info->monspecs, 0, sizeof(struct fb_monspecs)); -+ -+ /* If we didn't get all necessary data from the EDID block, -+ * mark it as incompatible with the GTF. */ -+ if (vesafb_vbe_getedid(tsk, info)) -+ info->monspecs.gtf = 0; -+ -+ /* Kernel command line overrides. */ -+ if (maxclk) -+ info->monspecs.dclkmax = maxclk * 1000000; -+ if (maxvf) -+ info->monspecs.vfmax = maxvf; -+ if (maxhf) -+ info->monspecs.hfmax = maxhf * 1000; -+ -+ /* In case DDC transfers are not supported the user can provide -+ * monitor limits manually. Lower limits are set to "safe" values. */ -+ if (info->monspecs.gtf == 0 && maxclk && maxvf && maxhf) { -+ info->monspecs.dclkmin = 0; -+ info->monspecs.vfmin = 60; -+ info->monspecs.hfmin = 29000; -+ info->monspecs.gtf = 1; -+ } -+ -+ if (info->monspecs.gtf) { -+ printk(KERN_INFO -+ "vesafb: monitor limits: vf = %d Hz, hf = %d kHz, " -+ "clk = %d MHz\n", info->monspecs.vfmax, -+ (int)(info->monspecs.hfmax / 1000), -+ (int)(info->monspecs.dclkmax / 1000000)); -+ /* Add valid VESA video modes to our modelist. */ -+ for (i = 0; i < VESA_MODEDB_SIZE; i++) { -+ fb_videomode_to_var(&var, (struct fb_videomode *) -+ &vesa_modes[i]); -+ if (!fb_validate_mode(&var, info)) -+ fb_add_videomode((struct fb_videomode *) -+ &vesa_modes[i], -+ &info->modelist); -+ } -+ } else { -+ /* Add all VESA video modes to our modelist. */ -+ fb_videomode_to_modelist((struct fb_videomode *)vesa_modes, -+ VESA_MODEDB_SIZE, &info->modelist); -+ printk(KERN_INFO "vesafb: no monitor limits have been set\n"); -+ } -+ return; -+} -+ -+static int __init inline vesafb_vbe_init(struct fb_info *info) -+{ -+ struct vesafb_task *tsk; -+ int res = 0; -+ -+ vesafb_create_task(tsk); -+ if (!tsk) -+ return -EINVAL; -+ if ((res = vesafb_vbe_getinfo(tsk)) != 0) -+ goto out; -+ if ((res = vesafb_vbe_getmodes(tsk)) != 0) -+ goto out; -+ if (pmi_setpal || ypan) -+ vesafb_vbe_getpmi(tsk); -+ -+ INIT_LIST_HEAD(&info->modelist); -+ vesafb_vbe_getmonspecs(tsk, info); -+ -+out: kfree(tsk); -+ return res; -+} -+ -+static int __init decode_mode(u32 *xres, u32 *yres, u32 *bpp, u32 *refresh) -+{ -+ int len = strlen(mode_option), i, err = 0; -+ u8 res_specified = 0, bpp_specified = 0, refresh_specified = 0, -+ yres_specified = 0; -+ -+ for (i = len-1; i >= 0; i--) { -+ switch (mode_option[i]) { -+ case '@': -+ len = i; -+ if (!refresh_specified && !bpp_specified && -+ !yres_specified) { -+ *refresh = simple_strtoul(&mode_option[i+1], -+ NULL, 0); -+ refresh_specified = 1; -+ } else -+ goto out; -+ break; -+ case '-': -+ len = i; -+ if (!bpp_specified && !yres_specified) { -+ *bpp = simple_strtoul(&mode_option[i+1], -+ NULL, 0); -+ bpp_specified = 1; -+ } else -+ goto out; -+ break; -+ case 'x': -+ if (!yres_specified) { -+ *yres = simple_strtoul(&mode_option[i+1], -+ NULL, 0); -+ yres_specified = 1; -+ } else -+ goto out; -+ break; -+ case '0'...'9': -+ break; -+ default: -+ goto out; -+ } -+ } -+ -+ if (i < 0 && yres_specified) { -+ *xres = simple_strtoul(mode_option, NULL, 0); -+ res_specified = 1; -+ } -+ -+out: if (!res_specified || !yres_specified) { -+ printk(KERN_ERR "vesafb: invalid resolution, " -+ "%s not specified\n", -+ (!res_specified) ? "width" : "height"); -+ err = -EINVAL; -+ } -+ -+ return err; -+} -+ -+static int __init vesafb_init_set_mode(struct fb_info *info) -+{ -+ struct fb_videomode *fbmode; -+ struct fb_videomode mode; -+ int i, modeid, refresh = 0; -+ u8 refresh_specified = 0; -+ -+ if (!mode_option) -+ mode_option = CONFIG_FB_VESA_DEFAULT_MODE; -+ -+ if (vbemode > 0) { -+ for (i = 0; i < vbe_modes_cnt; i++) { -+ if (vbe_modes[i].mode_id == vbemode) { -+ info->var.vmode = FB_VMODE_NONINTERLACED; -+ info->var.sync = FB_SYNC_VERT_HIGH_ACT; -+ vesafb_setup_var(&info->var, info, -+ &vbe_modes[i]); -+ fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, -+ 60, &info->var, info); -+ /* With pixclock set to 0, the default BIOS -+ * timings will be used in set_par(). */ -+ info->var.pixclock = 0; -+ modeid = i; -+ goto out; -+ } -+ } -+ printk(KERN_INFO "specified VBE mode %d not found\n", -+ vbemode); -+ vbemode = 0; -+ } -+ -+ /* Decode the mode specified on the kernel command line. We save -+ * the depth into bits_per_pixel, which is wrong, but will work -+ * anyway. */ -+ if (decode_mode(&info->var.xres, &info->var.yres, -+ &info->var.bits_per_pixel, &refresh)) -+ return -EINVAL; -+ if (refresh) -+ refresh_specified = 1; -+ else -+ refresh = 60; -+ -+ /* Look for a matching VBE mode. We can live if an exact match -+ * cannot be found. */ -+ modeid = vesafb_find_vbe_mode(info->var.xres, info->var.yres, -+ info->var.bits_per_pixel, 0); -+ -+ if (modeid == -1) { -+ return -EINVAL; -+ } else { -+ info->var.vmode = FB_VMODE_NONINTERLACED; -+ info->var.sync = FB_SYNC_VERT_HIGH_ACT; -+ vesafb_setup_var(&info->var, info, &vbe_modes[modeid]); -+ } -+ if (vbe_ib.vbe_version < 0x0300) { -+ fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, 60, -+ &info->var, info); -+ goto out; -+ } -+ if (!gtf) { -+ struct fb_videomode tmode; -+ -+ if (refresh_specified) { -+ fb_var_to_videomode(&tmode, &info->var); -+ tmode.refresh = refresh; -+ fbmode = fb_find_nearest_mode(&tmode, -+ &info->modelist); -+ } else -+ fbmode = fb_find_best_mode(&info->var, -+ &info->modelist); -+ -+ if (fbmode->xres == info->var.xres && -+ fbmode->yres == info->var.yres && -+ !(fbmode->vmode & (FB_VMODE_INTERLACED | FB_VMODE_DOUBLE)) -+ && (!refresh_specified || -+ abs(refresh - fbmode->refresh) <= 5)) { -+ fb_videomode_to_var(&info->var, fbmode); -+ return modeid; -+ } -+ } -+ i = FB_MAXTIMINGS; -+ if (!info->monspecs.gtf) -+ i = FB_IGNOREMON | FB_VSYNCTIMINGS; -+ else if (refresh_specified) -+ i = FB_VSYNCTIMINGS; -+ if (!fb_get_mode(i, refresh, &info->var, info)) -+ goto out; -+ if (info->monspecs.gtf && -+ !fb_get_mode(FB_MAXTIMINGS, 0, &info->var, info)) -+ goto out; -+ /* Use default refresh rate */ -+ printk(KERN_WARNING "vesafb: using default BIOS refresh rate\n"); -+ info->var.pixclock = 0; -+ -+out: -+ fb_var_to_videomode(&mode, &info->var); -+ fb_add_videomode(&mode, &info->modelist); -+ return modeid; -+} -+ -+static int __init vesafb_probe(struct platform_device *dev) -+{ -+ char entry[16]; -+ struct fb_info *info; -+ struct vesafb_mode_ib *mode = NULL; -+ int err = 0, i, h; -+ unsigned int size_vmode; -+ unsigned int size_remap; -+ unsigned int size_total; -+ -+ vesafb_info = info = framebuffer_alloc(sizeof(struct vesafb_par) + -+ sizeof(u32) * 256, &dev->dev); -+ if (!info) -+ return -ENOMEM; -+ -+ if (vesafb_wait_for_thread()) { -+ printk(KERN_ERR "vesafb: vesafb thread not running\n"); -+ framebuffer_release(info); -+ return -EINVAL; -+ } -+ -+ if (vesafb_vbe_init(info)) { -+ printk(KERN_ERR "vesafb: vbe_init failed\n"); -+ err = -EINVAL; -+ goto out; -+ } -+ -+ vesafb_fix.ypanstep = ypan ? 1 : 0; -+ vesafb_fix.ywrapstep = (ypan>1) ? 1 : 0; -+ -+ info->pseudo_palette = ((u8*)info->par + sizeof(struct vesafb_par)); -+ info->fbops = &vesafb_ops; -+ info->var = vesafb_defined; -+ info->fix = vesafb_fix; -+ -+ if (fb_alloc_cmap(&info->cmap, 256, 0) < 0) { -+ err = -ENXIO; -+ goto out; -+ } -+ -+ i = vesafb_init_set_mode(info); -+ if (i < 0) { -+ err = -EINVAL; -+ goto out_cmap; -+ } else -+ mode = &vbe_modes[i]; -+ -+ /* Disable blanking if the user requested so. */ -+ if (!blank) { -+ info->fbops->fb_blank = NULL; -+ } -+ -+ /* Find out how much IO memory is required for the mode with -+ * the highest resolution. */ -+ size_remap = 0; -+ for (i = 0; i < vbe_modes_cnt; i++) { -+ h = vbe_modes[i].bytes_per_scan_line * vbe_modes[i].y_res; -+ if (h > size_remap) -+ size_remap = h; -+ } -+ size_remap *= 2; -+ -+ /* size_vmode -- that is the amount of memory needed for the -+ * used video mode, i.e. the minimum amount of -+ * memory we need. */ -+ if (mode != NULL) { -+ size_vmode = info->var.yres * mode->bytes_per_scan_line; -+ } else { -+ size_vmode = info->var.yres * info->var.xres * -+ ((info->var.bits_per_pixel + 7) >> 3); -+ } -+ -+ /* size_total -- all video memory we have. Used for mtrr -+ * entries, ressource allocation and bounds -+ * checking. */ -+ size_total = vbe_ib.total_memory * 65536; -+ if (vram_total) -+ size_total = vram_total * 1024 * 1024; -+ if (size_total < size_vmode) -+ size_total = size_vmode; -+ ((struct vesafb_par*)(info->par))->mem_total = size_total; -+ -+ /* size_remap -- the amount of video memory we are going to -+ * use for vesafb. With modern cards it is no -+ * option to simply use size_total as th -+ * wastes plenty of kernel address space. */ -+ if (vram_remap) -+ size_remap = vram_remap * 1024 * 1024; -+ if (size_remap < size_vmode) -+ size_remap = size_vmode; -+ if (size_remap > size_total) -+ size_remap = size_total; -+ -+ info->fix.smem_len = size_remap; -+ info->fix.smem_start = mode->phys_base_ptr; -+ -+ /* We have to set it here, because when setup_var() was called, -+ * smem_len wasn't defined yet. */ -+ info->var.yres_virtual = info->fix.smem_len / -+ mode->bytes_per_scan_line; -+ -+ if (ypan && info->var.yres_virtual > info->var.yres) { -+ printk(KERN_INFO "vesafb: scrolling: %s " -+ "using protected mode interface, " -+ "yres_virtual=%d\n", -+ (ypan > 1) ? "ywrap" : "ypan",info->var.yres_virtual); -+ } else { -+ printk(KERN_INFO "vesafb: scrolling: redraw\n"); -+ info->var.yres_virtual = info->var.yres; -+ ypan = 0; -+ } -+ -+ info->flags = FBINFO_FLAG_DEFAULT | -+ (ypan) ? FBINFO_HWACCEL_YPAN : 0; -+ -+ if (!ypan) -+ info->fbops->fb_pan_display = NULL; -+ -+ if (!request_mem_region(info->fix.smem_start, size_total, "vesafb")) { -+ printk(KERN_WARNING "vesafb: cannot reserve video memory at " -+ "0x%lx\n", info->fix.smem_start); -+ /* We cannot make this fatal. Sometimes this comes from magic -+ spaces our resource handlers simply don't know about. */ -+ } -+ -+ info->screen_base = ioremap(info->fix.smem_start, info->fix.smem_len); -+ -+ if (!info->screen_base) { -+ printk(KERN_ERR -+ "vesafb: abort, cannot ioremap video memory " -+ "0x%x @ 0x%lx\n", -+ info->fix.smem_len, info->fix.smem_start); -+ err = -EIO; -+ goto out_mem; -+ } -+ -+ /* Request failure does not faze us, as vgacon probably has this -+ region already (FIXME) */ -+ request_region(0x3c0, 32, "vesafb"); -+ -+#ifdef CONFIG_MTRR -+ if (mtrr && !(info->fix.smem_start & (PAGE_SIZE - 1))) { -+ int temp_size = size_total; -+ unsigned int type = 0; -+ -+ switch (mtrr) { -+ case 1: -+ type = MTRR_TYPE_UNCACHABLE; -+ break; -+ case 2: -+ type = MTRR_TYPE_WRBACK; -+ break; -+ case 3: -+ type = MTRR_TYPE_WRCOMB; -+ break; -+ case 4: -+ type = MTRR_TYPE_WRTHROUGH; -+ break; -+ default: -+ type = 0; -+ break; -+ } -+ -+ if (type) { -+ int rc; -+ -+ /* Find the largest power-of-two */ -+ while (temp_size & (temp_size - 1)) -+ temp_size &= (temp_size - 1); -+ -+ /* Try and find a power of two to add */ -+ do { -+ rc = mtrr_add(info->fix.smem_start, -+ temp_size, type, 1); -+ temp_size >>= 1; -+ } while (temp_size >= PAGE_SIZE && rc == -EINVAL); -+ } -+ } -+#endif /* CONFIG_MTRR */ -+ -+ if (register_framebuffer(info) < 0) { -+ printk(KERN_ERR -+ "vesafb: failed to register framebuffer device\n"); -+ err = -EINVAL; -+ goto out_mem; -+ } -+ -+ printk(KERN_INFO "vesafb: framebuffer at 0x%lx, mapped to 0x%p, " -+ "using %dk, total %dk\n", info->fix.smem_start, -+ info->screen_base, size_remap/1024, size_total/1024); -+ printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node, -+ info->fix.id); -+ -+ sprintf(entry, "fb%d", info->node); -+ proc_mkdir(entry, 0); -+ -+ sprintf(entry, "fb%d/modes", info->node); -+ create_proc_read_entry(entry, 0, 0, vesafb_read_proc_modes, NULL); -+ -+ sprintf(entry, "fb%d/vbe_info", info->node); -+ create_proc_read_entry(entry, 0, 0, vesafb_read_proc_vbe_info, NULL); -+ return 0; -+ -+out_mem: -+ release_mem_region(info->fix.smem_start, size_total); -+ if (!list_empty(&info->modelist)) -+ fb_destroy_modelist(&info->modelist); -+ fb_destroy_modedb(info->monspecs.modedb); -+out_cmap: -+ fb_dealloc_cmap(&info->cmap); -+out: -+ framebuffer_release(info); -+ vesafb_info = NULL; -+ kfree(vbe_modes); -+ vbe_modes = NULL; -+ return err; -+} -+ -+int __init vesafb_init(void) -+{ -+ int ret; -+#ifndef MODULE -+ char *option = NULL; -+ -+ if (fb_get_options("vesafb", &option)) -+ return -ENODEV; -+ vesafb_setup(option); -+#endif -+ ret = platform_driver_register(&vesafb_driver); -+ -+ if (!ret) { -+ vesafb_device = platform_device_alloc("vesafb", 0); -+ -+ if (vesafb_device) -+ ret = platform_device_add(vesafb_device); -+ else -+ ret = -ENOMEM; -+ -+ if (ret) { -+ platform_device_put(vesafb_device); -+ platform_driver_unregister(&vesafb_driver); -+ } -+ } -+ return ret; -+} -+ -+module_init(vesafb_init); -+ -+#ifdef MODULE -+void __exit vesafb_exit(void) -+{ -+ char entry[16]; -+ -+ if (vesafb_info) -+ unregister_framebuffer(vesafb_info); -+ -+ platform_device_unregister(vesafb_device); -+ platform_driver_unregister(&vesafb_driver); -+ -+ if (vesafb_info) { -+ struct vesafb_par *par = (struct vesafb_par*)vesafb_info->par; -+ -+ sprintf(entry, "fb%d/modes", vesafb_info->node); -+ remove_proc_entry(entry, NULL); -+ -+ sprintf(entry, "fb%d/vbe_info", vesafb_info->node); -+ remove_proc_entry(entry, NULL); -+ -+ sprintf(entry, "fb%d", vesafb_info->node); -+ remove_proc_entry(entry, NULL); -+ -+ iounmap(vesafb_info->screen_base); -+ release_mem_region(vesafb_info->fix.smem_start, -+ par->mem_total); -+ fb_dealloc_cmap(&vesafb_info->cmap); -+ if (!list_empty(&vesafb_info->modelist)) -+ fb_destroy_modelist(&vesafb_info->modelist); -+ fb_destroy_modedb(vesafb_info->monspecs.modedb); -+ framebuffer_release(vesafb_info); -+ } -+ -+ if (vbe_modes != NULL) -+ kfree(vbe_modes); -+} -+ -+module_exit(vesafb_exit); -+ -+static inline int param_get_scroll(char *buffer, struct kernel_param *kp) -+{ -+ return 0; -+} -+static inline int param_set_scroll(const char *val, struct kernel_param *kp) -+{ -+ ypan = 0; -+ -+ if (! strcmp(val, "redraw")) -+ ypan = 0; -+ else if (! strcmp(val, "ypan")) -+ ypan = 1; -+ else if (! strcmp(val, "ywrap")) -+ ypan = 2; -+ -+ return 0; -+} -+ -+#define param_check_scroll(name, p) __param_check(name, p, void); -+ -+module_param_named(scroll, ypan, scroll, 0); -+MODULE_PARM_DESC(scroll,"Scrolling mode, set to 'redraw', 'ypan' or 'ywrap'"); -+module_param_named(vgapal, pmi_setpal, invbool, 0); -+MODULE_PARM_DESC(vgapal,"bool: set palette using VGA registers"); -+module_param_named(pmipal, pmi_setpal, bool, 0); -+MODULE_PARM_DESC(pmipal,"bool: set palette using PMI calls"); -+module_param(mtrr, uint, 0); -+MODULE_PARM_DESC(mtrr,"Memory Type Range Registers setting. Use 0 to disable."); -+module_param(blank, bool, 1); -+MODULE_PARM_DESC(blank,"bool: enable hardware blanking"); -+module_param(nocrtc, bool, 0); -+MODULE_PARM_DESC(nocrtc,"bool: ignore CRTC timings when setting modes"); -+module_param(noedid, bool, 0); -+MODULE_PARM_DESC(noedid,"bool: ignore EDID-provided monitor limits " -+ "when setting modes"); -+module_param(gtf, bool, 0); -+MODULE_PARM_DESC(gtf,"bool: force use of VESA GTF to calculate mode timings"); -+module_param(vram_remap, uint, 0); -+MODULE_PARM_DESC(vram_remap,"Set amount of video memory to be used [MiB]"); -+module_param(vram_total, uint, 0); -+MODULE_PARM_DESC(vram_total,"Set total amount of video memoery [MiB]"); -+module_param(maxclk, ushort, 0); -+MODULE_PARM_DESC(maxclk,"Maximum pixelclock [MHz], overrides EDID data"); -+module_param(maxhf, ushort, 0); -+MODULE_PARM_DESC(maxhf,"Maximum horizontal frequency [kHz], " -+ "overrides EDID data"); -+module_param(maxvf, ushort, 0); -+MODULE_PARM_DESC(maxvf,"Maximum vertical frequency [Hz], " -+ "overrides EDID data"); -+module_param_named(mode, mode_option, charp, 0); -+MODULE_PARM_DESC(mode, "Specify resolution as " -+ "\"<xres>x<yres>[-<bpp>][@<refresh>]\""); -+module_param(vbemode, ushort, 0); -+MODULE_PARM_DESC(vbemode,"VBE mode number to set, overrides 'mode' setting"); -+ -+#endif /* MODULE */ -+ -+MODULE_LICENSE("GPL"); -+MODULE_AUTHOR("Michal Januszewski"); -+MODULE_DESCRIPTION("Framebuffer driver for VBE2.0+ compliant graphics boards"); -+ -diff --git a/include/linux/sched.h b/include/linux/sched.h -index 4463735..7283e48 100644 ---- a/include/linux/sched.h -+++ b/include/linux/sched.h -@@ -1390,6 +1390,8 @@ extern void mmput(struct mm_struct *); - extern struct mm_struct *get_task_mm(struct task_struct *task); - /* Remove the current tasks stale references to the old mm_struct */ - extern void mm_release(struct task_struct *, struct mm_struct *); -+/* Create a new mm for a kernel thread */ -+extern int set_new_mm(void); - - extern int copy_thread(int, unsigned long, unsigned long, unsigned long, struct task_struct *, struct pt_regs *); - extern void flush_thread(void); -diff --git a/include/video/vesa.h b/include/video/vesa.h -new file mode 100644 -index 0000000..bb5abcf ---- /dev/null -+++ b/include/video/vesa.h -@@ -0,0 +1,150 @@ -+#if 0 -+#define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , \ -+ ## args) -+#else -+#define DPRINTK(fmt, args...) -+#endif -+ -+#define p_crtc(arg) ((struct vesafb_crtc_ib*)(arg)) -+#define p_vbe(arg) ((struct vesafb_vbe_ib*)(arg)) -+#define p_mode(arg) ((struct vesafb_mode_ib*)(arg)) -+ -+struct vesafb_task { -+ u8 flags; -+ void *buf; -+ int buf_len; -+ struct vm86_regs regs; -+ struct list_head node; -+ struct completion done; -+}; -+ -+/* Vesafb task flags and masks */ -+#define TF_CALL 0x00 -+#define TF_EXIT 0x01 -+#define TF_GETVBEIB 0x02 -+#define TF_BUF_DI 0x04 -+#define TF_BUF_BX 0x08 -+#define TF_RETURN_BUF 0x10 -+ -+/* Macros and functions for manipulating vesafb tasks */ -+#define vesafb_create_task(task) \ -+do { \ -+ task = kmalloc(sizeof(struct vesafb_task), GFP_ATOMIC); \ -+ if (task) \ -+ memset(task, 0, sizeof(struct vesafb_task)); \ -+ init_completion(&task->done); \ -+} while (0) -+ -+#define vesafb_wait_for_task(task) wait_for_completion(&task->done); -+#define vesafb_reset_task(task) init_completion(&task->done); -+int vesafb_queue_task(struct vesafb_task *task); -+ -+/* Functions for controlling the vesafb thread */ -+int vesafb_wait_for_thread(void); -+ -+#define VBE_CAP_CAN_SWITCH_DAC 0x01 -+#define VBE_CAP_VGACOMPAT 0x02 -+ -+/* This struct is 512 bytes long */ -+struct vesafb_vbe_ib { -+ char vbe_signature[4]; -+ u16 vbe_version; -+ u32 oem_string_ptr; -+ u32 capabilities; -+ u32 mode_list_ptr; -+ u16 total_memory; -+ u16 oem_software_rev; -+ u32 oem_vendor_name_ptr; -+ u32 oem_product_name_ptr; -+ u32 oem_product_rev_ptr; -+ u8 reserved[222]; -+ char oem_data[256]; -+} __attribute__ ((packed)); -+ -+struct vesafb_crtc_ib { -+ u16 horiz_total; -+ u16 horiz_start; -+ u16 horiz_end; -+ u16 vert_total; -+ u16 vert_start; -+ u16 vert_end; -+ u8 flags; -+ u32 pixel_clock; -+ u16 refresh_rate; -+ u8 reserved[40]; -+} __attribute__ ((packed)); -+ -+#define VBE_MODE_VGACOMPAT 0x20 -+ -+struct vesafb_mode_ib { -+ /* for all VBE revisions */ -+ u16 mode_attr; -+ u8 winA_attr; -+ u8 winB_attr; -+ u16 win_granularity; -+ u16 win_size; -+ u16 winA_seg; -+ u16 winB_seg; -+ u32 win_func_ptr; -+ u16 bytes_per_scan_line; -+ -+ /* for VBE 1.2+ */ -+ u16 x_res; -+ u16 y_res; -+ u8 x_char_size; -+ u8 y_char_size; -+ u8 planes; -+ u8 bits_per_pixel; -+ u8 banks; -+ u8 memory_model; -+ u8 bank_size; -+ u8 image_pages; -+ u8 reserved1; -+ -+ /* Direct color fields for direct/6 and YUV/7 memory models. */ -+ /* Offsets are bit positions of lsb in the mask. */ -+ u8 red_len; -+ u8 red_off; -+ u8 green_len; -+ u8 green_off; -+ u8 blue_len; -+ u8 blue_off; -+ u8 rsvd_len; -+ u8 rsvd_off; -+ u8 direct_color_info; /* direct color mode attributes */ -+ -+ /* for VBE 2.0+ */ -+ u32 phys_base_ptr; -+ u8 reserved2[6]; -+ -+ /* for VBE 3.0+ */ -+ u16 lin_bytes_per_scan_line; -+ u8 bnk_image_pages; -+ u8 lin_image_pages; -+ u8 lin_red_len; -+ u8 lin_red_off; -+ u8 lin_green_len; -+ u8 lin_green_off; -+ u8 lin_blue_len; -+ u8 lin_blue_off; -+ u8 lin_rsvd_len; -+ u8 lin_rsvd_off; -+ u32 max_pixel_clock; -+ u16 mode_id; -+ u8 depth; -+} __attribute__ ((packed)); -+ -+struct vesafb_pal_entry { -+ u_char blue, green, red, pad; -+} __attribute__ ((packed)); -+ -+struct vesafb_par { -+ u8 *vbe_state; -+ int vbe_state_size; -+ atomic_t ref_count; -+ -+ u32 mem_total; -+ int mode_idx; -+ struct vesafb_crtc_ib crtc; -+}; -+ -diff --git a/kernel/fork.c b/kernel/fork.c -index fc723e5..dc8f93b 100644 ---- a/kernel/fork.c -+++ b/kernel/fork.c -@@ -100,6 +100,7 @@ struct kmem_cache *fs_cachep; - - /* SLAB cache for vm_area_struct structures */ - struct kmem_cache *vm_area_cachep; -+EXPORT_SYMBOL_GPL(vm_area_cachep); - - /* SLAB cache for mm_struct structures (tsk->mm) */ - static struct kmem_cache *mm_cachep; -@@ -399,6 +400,40 @@ void mmput(struct mm_struct *mm) - EXPORT_SYMBOL_GPL(mmput); - - /** -+ * set_new_mm - allocate, init and activate a new mm for a kernel thread -+ */ -+int set_new_mm(void) -+{ -+ struct mm_struct *mm; -+ struct task_struct *tsk = current; -+ struct mm_struct *active_mm; -+ -+ mm = mm_alloc(); -+ if (!mm) -+ goto fail_nomem; -+ if (init_new_context(current,mm)) -+ goto fail_nocontext; -+ -+ task_lock(tsk); -+ tsk->flags |= PF_BORROWED_MM; -+ active_mm = tsk->active_mm; -+ current->mm = mm; -+ current->active_mm = mm; -+ activate_mm(active_mm, mm); -+ task_unlock(current); -+ -+ /* Drop the previous active_mm */ -+ mmdrop(active_mm); -+ return 0; -+ -+fail_nocontext: -+ mmdrop(mm); -+fail_nomem: -+ return -EINVAL; -+} -+EXPORT_SYMBOL_GPL(set_new_mm); -+ -+/** - * get_task_mm - acquire a reference to the task's mm - * - * Returns %NULL if the task has no mm. Checks PF_BORROWED_MM (meaning -diff --git a/mm/memory.c b/mm/memory.c -index 563792f..a9519ea 100644 ---- a/mm/memory.c -+++ b/mm/memory.c -@@ -1193,6 +1193,7 @@ int zeromap_page_range(struct vm_area_struct *vma, - } while (pgd++, addr = next, addr != end); - return err; - } -+EXPORT_SYMBOL_GPL(zeromap_page_range); - - pte_t * fastcall get_locked_pte(struct mm_struct *mm, unsigned long addr, spinlock_t **ptl) - { -diff --git a/mm/mmap.c b/mm/mmap.c -index 9717337..6fa5b1c 100644 ---- a/mm/mmap.c -+++ b/mm/mmap.c -@@ -2024,6 +2024,7 @@ int insert_vm_struct(struct mm_struct * mm, struct vm_area_struct * vma) - vma_link(mm, vma, prev, rb_link, rb_parent); - return 0; - } -+EXPORT_SYMBOL_GPL(insert_vm_struct); - - /* - * Copy the vma structure to a new location in the same mm, |