2 * framebuffer driver for VBE 2.0 compliant graphic boards
4 * switching to graphics mode happens at boot time (while
5 * running in real mode, see arch/i386/boot/video.S).
7 * (c) 1998 Gerd Knorr <kraxel@goldbach.in-berlin.de>
11 #include <linux/module.h>
12 #include <linux/kernel.h>
13 #include <linux/errno.h>
14 #include <linux/string.h>
16 #include <linux/tty.h>
17 #include <linux/slab.h>
18 #include <linux/delay.h>
20 #include <linux/ioport.h>
21 #include <linux/init.h>
22 #include <linux/platform_device.h>
24 #include <video/vga.h>
28 #define dac_reg (0x3c8)
29 #define dac_val (0x3c9)
31 /* --------------------------------------------------------------------- */
33 static struct fb_var_screeninfo vesafb_defined __initdata
= {
34 .activate
= FB_ACTIVATE_NOW
,
41 .vmode
= FB_VMODE_NONINTERLACED
,
44 static struct fb_fix_screeninfo vesafb_fix __initdata
= {
46 .type
= FB_TYPE_PACKED_PIXELS
,
47 .accel
= FB_ACCEL_NONE
,
50 static int inverse
= 0;
51 static int mtrr
= 0; /* disable mtrr */
52 static int vram_remap __initdata
= 0; /* Set amount of memory to be used */
53 static int vram_total __initdata
= 0; /* Set total amount of memory */
54 static int pmi_setpal
= 0; /* pmi for palette changes ??? */
55 static int ypan
= 0; /* 0..nothing, 1..ypan, 2..ywrap */
56 static unsigned short *pmi_base
= NULL
;
57 static void (*pmi_start
)(void);
58 static void (*pmi_pal
)(void);
60 static int vga_compat
;
62 /* --------------------------------------------------------------------- */
64 static int vesafb_pan_display(struct fb_var_screeninfo
*var
,
74 if (var
->yoffset
> var
->yres_virtual
)
76 if ((ypan
==1) && var
->yoffset
+var
->yres
> var
->yres_virtual
)
79 offset
= (var
->yoffset
* info
->fix
.line_length
+ var
->xoffset
) / 4;
83 : /* no return value */
84 : "a" (0x4f07), /* EAX */
86 "c" (offset
), /* ECX */
87 "d" (offset
>> 16), /* EDX */
88 "D" (&pmi_start
)); /* EDI */
93 static int vesafb_blank(int blank
, struct fb_info
*info
)
99 u8 seq
= 0, crtc17
= 0;
101 if (blank
== FB_BLANK_POWERDOWN
) {
108 err
= (blank
== FB_BLANK_UNBLANK
) ? 0 : -EINVAL
;
111 vga_wseq(NULL
, 0x00, 0x01);
112 seq
|= vga_rseq(NULL
, 0x01) & ~0x20;
113 vga_wseq(NULL
, 0x00, seq
);
115 crtc17
|= vga_rcrt(NULL
, 0x17) & ~0x80;
117 vga_wcrt(NULL
, 0x17, crtc17
);
118 vga_wseq(NULL
, 0x00, 0x03);
124 static void vesa_setpalette(int regno
, unsigned red
, unsigned green
,
128 struct { u_char blue
, green
, red
, pad
; } entry
;
129 int shift
= 16 - depth
;
132 entry
.red
= red
>> shift
;
133 entry
.green
= green
>> shift
;
134 entry
.blue
= blue
>> shift
;
136 __asm__
__volatile__(
138 : /* no return value */
139 : "a" (0x4f09), /* EAX */
142 "d" (regno
), /* EDX */
143 "D" (&entry
), /* EDI */
144 "S" (&pmi_pal
)); /* ESI */
146 /* without protected mode interface, try VGA registers... */
147 outb_p(regno
, dac_reg
);
148 outb_p(red
>> shift
, dac_val
);
149 outb_p(green
>> shift
, dac_val
);
150 outb_p(blue
>> shift
, dac_val
);
155 static int vesafb_setcolreg(unsigned regno
, unsigned red
, unsigned green
,
156 unsigned blue
, unsigned transp
,
157 struct fb_info
*info
)
160 * Set a single color register. The values supplied are
161 * already rounded down to the hardware's capabilities
162 * (according to the entries in the `var' structure). Return
163 * != 0 for invalid regno.
166 if (regno
>= info
->cmap
.len
)
169 if (info
->var
.bits_per_pixel
== 8)
170 vesa_setpalette(regno
,red
,green
,blue
);
171 else if (regno
< 16) {
172 switch (info
->var
.bits_per_pixel
) {
174 if (info
->var
.red
.offset
== 10) {
176 ((u32
*) (info
->pseudo_palette
))[regno
] =
177 ((red
& 0xf800) >> 1) |
178 ((green
& 0xf800) >> 6) |
179 ((blue
& 0xf800) >> 11);
182 ((u32
*) (info
->pseudo_palette
))[regno
] =
184 ((green
& 0xfc00) >> 5) |
185 ((blue
& 0xf800) >> 11);
193 ((u32
*)(info
->pseudo_palette
))[regno
] =
194 (red
<< info
->var
.red
.offset
) |
195 (green
<< info
->var
.green
.offset
) |
196 (blue
<< info
->var
.blue
.offset
);
204 static struct fb_ops vesafb_ops
= {
205 .owner
= THIS_MODULE
,
206 .fb_setcolreg
= vesafb_setcolreg
,
207 .fb_pan_display
= vesafb_pan_display
,
208 .fb_blank
= vesafb_blank
,
209 .fb_fillrect
= cfb_fillrect
,
210 .fb_copyarea
= cfb_copyarea
,
211 .fb_imageblit
= cfb_imageblit
,
214 static int __init
vesafb_setup(char *options
)
218 if (!options
|| !*options
)
221 while ((this_opt
= strsep(&options
, ",")) != NULL
) {
222 if (!*this_opt
) continue;
224 if (! strcmp(this_opt
, "inverse"))
226 else if (! strcmp(this_opt
, "redraw"))
228 else if (! strcmp(this_opt
, "ypan"))
230 else if (! strcmp(this_opt
, "ywrap"))
232 else if (! strcmp(this_opt
, "vgapal"))
234 else if (! strcmp(this_opt
, "pmipal"))
236 else if (! strncmp(this_opt
, "mtrr:", 5))
237 mtrr
= simple_strtoul(this_opt
+5, NULL
, 0);
238 else if (! strcmp(this_opt
, "nomtrr"))
240 else if (! strncmp(this_opt
, "vtotal:", 7))
241 vram_total
= simple_strtoul(this_opt
+7, NULL
, 0);
242 else if (! strncmp(this_opt
, "vremap:", 7))
243 vram_remap
= simple_strtoul(this_opt
+7, NULL
, 0);
248 static int __init
vesafb_probe(struct device
*device
)
250 struct platform_device
*dev
= to_platform_device(device
);
251 struct fb_info
*info
;
253 unsigned int size_vmode
;
254 unsigned int size_remap
;
255 unsigned int size_total
;
257 if (screen_info
.orig_video_isVGA
!= VIDEO_TYPE_VLFB
)
260 vesafb_fix
.smem_start
= screen_info
.lfb_base
;
261 vesafb_defined
.bits_per_pixel
= screen_info
.lfb_depth
;
262 if (15 == vesafb_defined
.bits_per_pixel
)
263 vesafb_defined
.bits_per_pixel
= 16;
264 vesafb_defined
.xres
= screen_info
.lfb_width
;
265 vesafb_defined
.yres
= screen_info
.lfb_height
;
266 vesafb_fix
.line_length
= screen_info
.lfb_linelength
;
267 vesafb_fix
.visual
= (vesafb_defined
.bits_per_pixel
== 8) ?
268 FB_VISUAL_PSEUDOCOLOR
: FB_VISUAL_TRUECOLOR
;
270 /* size_vmode -- that is the amount of memory needed for the
271 * used video mode, i.e. the minimum amount of
273 size_vmode
= vesafb_defined
.yres
* vesafb_fix
.line_length
;
275 /* size_total -- all video memory we have. Used for mtrr
276 * entries, ressource allocation and bounds
278 size_total
= screen_info
.lfb_size
* 65536;
280 size_total
= vram_total
* 1024 * 1024;
281 if (size_total
< size_vmode
)
282 size_total
= size_vmode
;
284 /* size_remap -- the amount of video memory we are going to
285 * use for vesafb. With modern cards it is no
286 * option to simply use size_total as that
287 * wastes plenty of kernel address space. */
288 size_remap
= size_vmode
* 2;
290 size_remap
= vram_remap
* 1024 * 1024;
291 if (size_remap
< size_vmode
)
292 size_remap
= size_vmode
;
293 if (size_remap
> size_total
)
294 size_remap
= size_total
;
295 vesafb_fix
.smem_len
= size_remap
;
298 screen_info
.vesapm_seg
= 0;
301 if (!request_mem_region(vesafb_fix
.smem_start
, size_total
, "vesafb")) {
303 "vesafb: cannot reserve video memory at 0x%lx\n",
304 vesafb_fix
.smem_start
);
305 /* We cannot make this fatal. Sometimes this comes from magic
306 spaces our resource handlers simply don't know about */
309 info
= framebuffer_alloc(sizeof(u32
) * 256, &dev
->dev
);
311 release_mem_region(vesafb_fix
.smem_start
, size_total
);
314 info
->pseudo_palette
= info
->par
;
317 info
->screen_base
= ioremap(vesafb_fix
.smem_start
, vesafb_fix
.smem_len
);
318 if (!info
->screen_base
) {
320 "vesafb: abort, cannot ioremap video memory 0x%x @ 0x%lx\n",
321 vesafb_fix
.smem_len
, vesafb_fix
.smem_start
);
326 printk(KERN_INFO
"vesafb: framebuffer at 0x%lx, mapped to 0x%p, "
327 "using %dk, total %dk\n",
328 vesafb_fix
.smem_start
, info
->screen_base
,
329 size_remap
/1024, size_total
/1024);
330 printk(KERN_INFO
"vesafb: mode is %dx%dx%d, linelength=%d, pages=%d\n",
331 vesafb_defined
.xres
, vesafb_defined
.yres
, vesafb_defined
.bits_per_pixel
, vesafb_fix
.line_length
, screen_info
.pages
);
333 if (screen_info
.vesapm_seg
) {
334 printk(KERN_INFO
"vesafb: protected mode interface info at %04x:%04x\n",
335 screen_info
.vesapm_seg
,screen_info
.vesapm_off
);
338 if (screen_info
.vesapm_seg
< 0xc000)
339 ypan
= pmi_setpal
= 0; /* not available or some DOS TSR ... */
341 if (ypan
|| pmi_setpal
) {
342 pmi_base
= (unsigned short*)phys_to_virt(((unsigned long)screen_info
.vesapm_seg
<< 4) + screen_info
.vesapm_off
);
343 pmi_start
= (void*)((char*)pmi_base
+ pmi_base
[1]);
344 pmi_pal
= (void*)((char*)pmi_base
+ pmi_base
[2]);
345 printk(KERN_INFO
"vesafb: pmi: set display start = %p, set palette = %p\n",pmi_start
,pmi_pal
);
347 printk(KERN_INFO
"vesafb: pmi: ports = ");
348 for (i
= pmi_base
[3]/2; pmi_base
[i
] != 0xffff; i
++)
349 printk("%x ",pmi_base
[i
]);
351 if (pmi_base
[i
] != 0xffff) {
353 * memory areas not supported (yet?)
355 * Rules are: we have to set up a descriptor for the requested
356 * memory area and pass it in the ES register to the BIOS function.
358 printk(KERN_INFO
"vesafb: can't handle memory requests, pmi disabled\n");
359 ypan
= pmi_setpal
= 0;
364 vesafb_defined
.xres_virtual
= vesafb_defined
.xres
;
365 vesafb_defined
.yres_virtual
= vesafb_fix
.smem_len
/ vesafb_fix
.line_length
;
366 if (ypan
&& vesafb_defined
.yres_virtual
> vesafb_defined
.yres
) {
367 printk(KERN_INFO
"vesafb: scrolling: %s using protected mode interface, yres_virtual=%d\n",
368 (ypan
> 1) ? "ywrap" : "ypan",vesafb_defined
.yres_virtual
);
370 printk(KERN_INFO
"vesafb: scrolling: redraw\n");
371 vesafb_defined
.yres_virtual
= vesafb_defined
.yres
;
375 /* some dummy values for timing to make fbset happy */
376 vesafb_defined
.pixclock
= 10000000 / vesafb_defined
.xres
* 1000 / vesafb_defined
.yres
;
377 vesafb_defined
.left_margin
= (vesafb_defined
.xres
/ 8) & 0xf8;
378 vesafb_defined
.hsync_len
= (vesafb_defined
.xres
/ 8) & 0xf8;
380 vesafb_defined
.red
.offset
= screen_info
.red_pos
;
381 vesafb_defined
.red
.length
= screen_info
.red_size
;
382 vesafb_defined
.green
.offset
= screen_info
.green_pos
;
383 vesafb_defined
.green
.length
= screen_info
.green_size
;
384 vesafb_defined
.blue
.offset
= screen_info
.blue_pos
;
385 vesafb_defined
.blue
.length
= screen_info
.blue_size
;
386 vesafb_defined
.transp
.offset
= screen_info
.rsvd_pos
;
387 vesafb_defined
.transp
.length
= screen_info
.rsvd_size
;
389 if (vesafb_defined
.bits_per_pixel
<= 8) {
390 depth
= vesafb_defined
.green
.length
;
391 vesafb_defined
.red
.length
=
392 vesafb_defined
.green
.length
=
393 vesafb_defined
.blue
.length
=
394 vesafb_defined
.bits_per_pixel
;
397 printk(KERN_INFO
"vesafb: %s: "
398 "size=%d:%d:%d:%d, shift=%d:%d:%d:%d\n",
399 (vesafb_defined
.bits_per_pixel
> 8) ?
400 "Truecolor" : "Pseudocolor",
401 screen_info
.rsvd_size
,
402 screen_info
.red_size
,
403 screen_info
.green_size
,
404 screen_info
.blue_size
,
405 screen_info
.rsvd_pos
,
407 screen_info
.green_pos
,
408 screen_info
.blue_pos
);
410 vesafb_fix
.ypanstep
= ypan
? 1 : 0;
411 vesafb_fix
.ywrapstep
= (ypan
>1) ? 1 : 0;
413 /* request failure does not faze us, as vgacon probably has this
414 * region already (FIXME) */
415 request_region(0x3c0, 32, "vesafb");
418 unsigned int temp_size
= size_total
;
419 unsigned int type
= 0;
423 type
= MTRR_TYPE_UNCACHABLE
;
426 type
= MTRR_TYPE_WRBACK
;
429 type
= MTRR_TYPE_WRCOMB
;
432 type
= MTRR_TYPE_WRTHROUGH
;
442 /* Find the largest power-of-two */
443 while (temp_size
& (temp_size
- 1))
444 temp_size
&= (temp_size
- 1);
446 /* Try and find a power of two to add */
448 rc
= mtrr_add(vesafb_fix
.smem_start
, temp_size
,
451 } while (temp_size
>= PAGE_SIZE
&& rc
== -EINVAL
);
455 info
->fbops
= &vesafb_ops
;
456 info
->var
= vesafb_defined
;
457 info
->fix
= vesafb_fix
;
458 info
->flags
= FBINFO_FLAG_DEFAULT
|
459 (ypan
) ? FBINFO_HWACCEL_YPAN
: 0;
461 vga_compat
= (screen_info
.capabilities
& 2) ? 0 : 1;
462 printk("vesafb: Mode is %sVGA compatible\n",
463 (vga_compat
) ? "" : "not ");
465 if (fb_alloc_cmap(&info
->cmap
, 256, 0) < 0) {
469 if (register_framebuffer(info
)<0) {
471 fb_dealloc_cmap(&info
->cmap
);
474 printk(KERN_INFO
"fb%d: %s frame buffer device\n",
475 info
->node
, info
->fix
.id
);
478 framebuffer_release(info
);
479 release_mem_region(vesafb_fix
.smem_start
, size_total
);
483 static struct device_driver vesafb_driver
= {
485 .bus
= &platform_bus_type
,
486 .probe
= vesafb_probe
,
489 static struct platform_device vesafb_device
= {
493 static int __init
vesafb_init(void)
498 /* ignore error return of fb_get_options */
499 fb_get_options("vesafb", &option
);
500 vesafb_setup(option
);
501 ret
= driver_register(&vesafb_driver
);
504 ret
= platform_device_register(&vesafb_device
);
506 driver_unregister(&vesafb_driver
);
510 module_init(vesafb_init
);
512 MODULE_LICENSE("GPL");