2 * A framebuffer driver for VBE 2.0+ compliant video cards
4 * (c) 2007 Michal Januszewski <spock@gentoo.org>
5 * Loosely based upon the vesafb driver.
8 #include <linux/init.h>
9 #include <linux/module.h>
10 #include <linux/moduleparam.h>
11 #include <linux/skbuff.h>
12 #include <linux/timer.h>
13 #include <linux/completion.h>
14 #include <linux/connector.h>
15 #include <linux/random.h>
16 #include <linux/platform_device.h>
17 #include <linux/limits.h>
20 #include <linux/mutex.h>
21 #include <linux/slab.h>
22 #include <video/edid.h>
23 #include <video/uvesafb.h>
25 #include <video/vga.h>
32 static struct cb_id uvesafb_cn_id
= {
34 .val
= CN_VAL_V86D_UVESAFB
36 static char v86d_path
[PATH_MAX
] = "/sbin/v86d";
37 static char v86d_started
; /* has v86d been started by uvesafb? */
39 static struct fb_fix_screeninfo uvesafb_fix __devinitdata
= {
41 .type
= FB_TYPE_PACKED_PIXELS
,
42 .accel
= FB_ACCEL_NONE
,
43 .visual
= FB_VISUAL_TRUECOLOR
,
46 static int mtrr __devinitdata
= 3; /* enable mtrr by default */
47 static bool blank
= 1; /* enable blanking by default */
48 static int ypan
= 1; /* 0: scroll, 1: ypan, 2: ywrap */
49 static bool pmi_setpal __devinitdata
= true; /* use PMI for palette changes */
50 static bool nocrtc __devinitdata
; /* ignore CRTC settings */
51 static bool noedid __devinitdata
; /* don't try DDC transfers */
52 static int vram_remap __devinitdata
; /* set amt. of memory to be used */
53 static int vram_total __devinitdata
; /* set total amount of memory */
54 static u16 maxclk __devinitdata
; /* maximum pixel clock */
55 static u16 maxvf __devinitdata
; /* maximum vertical frequency */
56 static u16 maxhf __devinitdata
; /* maximum horizontal frequency */
57 static u16 vbemode __devinitdata
; /* force use of a specific VBE mode */
58 static char *mode_option __devinitdata
;
59 static u8 dac_width
= 6;
61 static struct uvesafb_ktask
*uvfb_tasks
[UVESAFB_TASKS_MAX
];
62 static DEFINE_MUTEX(uvfb_lock
);
65 * A handler for replies from userspace.
67 * Make sure each message passes consistency checks and if it does,
68 * find the kernel part of the task struct, copy the registers and
69 * the buffer contents and then complete the task.
71 static void uvesafb_cn_callback(struct cn_msg
*msg
, struct netlink_skb_parms
*nsp
)
73 struct uvesafb_task
*utask
;
74 struct uvesafb_ktask
*task
;
76 if (!capable(CAP_SYS_ADMIN
))
79 if (msg
->seq
>= UVESAFB_TASKS_MAX
)
82 mutex_lock(&uvfb_lock
);
83 task
= uvfb_tasks
[msg
->seq
];
85 if (!task
|| msg
->ack
!= task
->ack
) {
86 mutex_unlock(&uvfb_lock
);
90 utask
= (struct uvesafb_task
*)msg
->data
;
92 /* Sanity checks for the buffer length. */
93 if (task
->t
.buf_len
< utask
->buf_len
||
94 utask
->buf_len
> msg
->len
- sizeof(*utask
)) {
95 mutex_unlock(&uvfb_lock
);
99 uvfb_tasks
[msg
->seq
] = NULL
;
100 mutex_unlock(&uvfb_lock
);
102 memcpy(&task
->t
, utask
, sizeof(*utask
));
104 if (task
->t
.buf_len
&& task
->buf
)
105 memcpy(task
->buf
, utask
+ 1, task
->t
.buf_len
);
107 complete(task
->done
);
111 static int uvesafb_helper_start(void)
124 return call_usermodehelper(v86d_path
, argv
, envp
, UMH_WAIT_PROC
);
128 * Execute a uvesafb task.
130 * Returns 0 if the task is executed successfully.
132 * A message sent to the userspace consists of the uvesafb_task
133 * struct and (optionally) a buffer. The uvesafb_task struct is
134 * a simplified version of uvesafb_ktask (its kernel counterpart)
135 * containing only the register values, flags and the length of
138 * Each message is assigned a sequence number (increased linearly)
139 * and a random ack number. The sequence number is used as a key
140 * for the uvfb_tasks array which holds pointers to uvesafb_ktask
141 * structs for all requests.
143 static int uvesafb_exec(struct uvesafb_ktask
*task
)
148 int len
= sizeof(task
->t
) + task
->t
.buf_len
;
151 * Check whether the message isn't longer than the maximum
152 * allowed by connector.
154 if (sizeof(*m
) + len
> CONNECTOR_MAX_MSG_SIZE
) {
155 printk(KERN_WARNING
"uvesafb: message too long (%d), "
156 "can't execute task\n", (int)(sizeof(*m
) + len
));
160 m
= kzalloc(sizeof(*m
) + len
, GFP_KERNEL
);
164 init_completion(task
->done
);
166 memcpy(&m
->id
, &uvesafb_cn_id
, sizeof(m
->id
));
171 /* uvesafb_task structure */
172 memcpy(m
+ 1, &task
->t
, sizeof(task
->t
));
175 memcpy((u8
*)(m
+ 1) + sizeof(task
->t
), task
->buf
, task
->t
.buf_len
);
178 * Save the message ack number so that we can find the kernel
179 * part of this task when a reply is received from userspace.
183 mutex_lock(&uvfb_lock
);
185 /* If all slots are taken -- bail out. */
186 if (uvfb_tasks
[seq
]) {
187 mutex_unlock(&uvfb_lock
);
192 /* Save a pointer to the kernel part of the task struct. */
193 uvfb_tasks
[seq
] = task
;
194 mutex_unlock(&uvfb_lock
);
196 err
= cn_netlink_send(m
, 0, GFP_KERNEL
);
199 * Try to start the userspace helper if sending
200 * the request failed the first time.
202 err
= uvesafb_helper_start();
204 printk(KERN_ERR
"uvesafb: failed to execute %s\n",
206 printk(KERN_ERR
"uvesafb: make sure that the v86d "
207 "helper is installed and executable\n");
210 err
= cn_netlink_send(m
, 0, gfp_any());
214 } else if (err
== -ENOBUFS
)
217 if (!err
&& !(task
->t
.flags
& TF_EXIT
))
218 err
= !wait_for_completion_timeout(task
->done
,
219 msecs_to_jiffies(UVESAFB_TIMEOUT
));
221 mutex_lock(&uvfb_lock
);
222 uvfb_tasks
[seq
] = NULL
;
223 mutex_unlock(&uvfb_lock
);
226 if (seq
>= UVESAFB_TASKS_MAX
)
234 * Free a uvesafb_ktask struct.
236 static void uvesafb_free(struct uvesafb_ktask
*task
)
246 * Prepare a uvesafb_ktask struct to be used again.
248 static void uvesafb_reset(struct uvesafb_ktask
*task
)
250 struct completion
*cpl
= task
->done
;
252 memset(task
, 0, sizeof(*task
));
257 * Allocate and prepare a uvesafb_ktask struct.
259 static struct uvesafb_ktask
*uvesafb_prep(void)
261 struct uvesafb_ktask
*task
;
263 task
= kzalloc(sizeof(*task
), GFP_KERNEL
);
265 task
->done
= kzalloc(sizeof(*task
->done
), GFP_KERNEL
);
274 static void uvesafb_setup_var(struct fb_var_screeninfo
*var
,
275 struct fb_info
*info
, struct vbe_mode_ib
*mode
)
277 struct uvesafb_par
*par
= info
->par
;
279 var
->vmode
= FB_VMODE_NONINTERLACED
;
280 var
->sync
= FB_SYNC_VERT_HIGH_ACT
;
282 var
->xres
= mode
->x_res
;
283 var
->yres
= mode
->y_res
;
284 var
->xres_virtual
= mode
->x_res
;
285 var
->yres_virtual
= (par
->ypan
) ?
286 info
->fix
.smem_len
/ mode
->bytes_per_scan_line
:
290 var
->bits_per_pixel
= mode
->bits_per_pixel
;
292 if (var
->bits_per_pixel
== 15)
293 var
->bits_per_pixel
= 16;
295 if (var
->bits_per_pixel
> 8) {
296 var
->red
.offset
= mode
->red_off
;
297 var
->red
.length
= mode
->red_len
;
298 var
->green
.offset
= mode
->green_off
;
299 var
->green
.length
= mode
->green_len
;
300 var
->blue
.offset
= mode
->blue_off
;
301 var
->blue
.length
= mode
->blue_len
;
302 var
->transp
.offset
= mode
->rsvd_off
;
303 var
->transp
.length
= mode
->rsvd_len
;
306 var
->green
.offset
= 0;
307 var
->blue
.offset
= 0;
308 var
->transp
.offset
= 0;
311 var
->green
.length
= 8;
312 var
->blue
.length
= 8;
313 var
->transp
.length
= 0;
317 static int uvesafb_vbe_find_mode(struct uvesafb_par
*par
,
318 int xres
, int yres
, int depth
, unsigned char flags
)
320 int i
, match
= -1, h
= 0, d
= 0x7fffffff;
322 for (i
= 0; i
< par
->vbe_modes_cnt
; i
++) {
323 h
= abs(par
->vbe_modes
[i
].x_res
- xres
) +
324 abs(par
->vbe_modes
[i
].y_res
- yres
) +
325 abs(depth
- par
->vbe_modes
[i
].depth
);
328 * We have an exact match in terms of resolution
334 if (h
< d
|| (h
== d
&& par
->vbe_modes
[i
].depth
> depth
)) {
341 if (flags
& UVESAFB_EXACT_DEPTH
&&
342 par
->vbe_modes
[match
].depth
!= depth
)
345 if (flags
& UVESAFB_EXACT_RES
&& d
> 24)
354 static u8
*uvesafb_vbe_state_save(struct uvesafb_par
*par
)
356 struct uvesafb_ktask
*task
;
360 if (!par
->vbe_state_size
)
363 state
= kmalloc(par
->vbe_state_size
, GFP_KERNEL
);
365 return ERR_PTR(-ENOMEM
);
367 task
= uvesafb_prep();
373 task
->t
.regs
.eax
= 0x4f04;
374 task
->t
.regs
.ecx
= 0x000f;
375 task
->t
.regs
.edx
= 0x0001;
376 task
->t
.flags
= TF_BUF_RET
| TF_BUF_ESBX
;
377 task
->t
.buf_len
= par
->vbe_state_size
;
379 err
= uvesafb_exec(task
);
381 if (err
|| (task
->t
.regs
.eax
& 0xffff) != 0x004f) {
382 printk(KERN_WARNING
"uvesafb: VBE get state call "
383 "failed (eax=0x%x, err=%d)\n",
384 task
->t
.regs
.eax
, err
);
393 static void uvesafb_vbe_state_restore(struct uvesafb_par
*par
, u8
*state_buf
)
395 struct uvesafb_ktask
*task
;
401 task
= uvesafb_prep();
405 task
->t
.regs
.eax
= 0x4f04;
406 task
->t
.regs
.ecx
= 0x000f;
407 task
->t
.regs
.edx
= 0x0002;
408 task
->t
.buf_len
= par
->vbe_state_size
;
409 task
->t
.flags
= TF_BUF_ESBX
;
410 task
->buf
= state_buf
;
412 err
= uvesafb_exec(task
);
413 if (err
|| (task
->t
.regs
.eax
& 0xffff) != 0x004f)
414 printk(KERN_WARNING
"uvesafb: VBE state restore call "
415 "failed (eax=0x%x, err=%d)\n",
416 task
->t
.regs
.eax
, err
);
421 static int __devinit
uvesafb_vbe_getinfo(struct uvesafb_ktask
*task
,
422 struct uvesafb_par
*par
)
426 task
->t
.regs
.eax
= 0x4f00;
427 task
->t
.flags
= TF_VBEIB
;
428 task
->t
.buf_len
= sizeof(struct vbe_ib
);
429 task
->buf
= &par
->vbe_ib
;
430 strncpy(par
->vbe_ib
.vbe_signature
, "VBE2", 4);
432 err
= uvesafb_exec(task
);
433 if (err
|| (task
->t
.regs
.eax
& 0xffff) != 0x004f) {
434 printk(KERN_ERR
"uvesafb: Getting VBE info block failed "
435 "(eax=0x%x, err=%d)\n", (u32
)task
->t
.regs
.eax
,
440 if (par
->vbe_ib
.vbe_version
< 0x0200) {
441 printk(KERN_ERR
"uvesafb: Sorry, pre-VBE 2.0 cards are "
446 if (!par
->vbe_ib
.mode_list_ptr
) {
447 printk(KERN_ERR
"uvesafb: Missing mode list!\n");
451 printk(KERN_INFO
"uvesafb: ");
454 * Convert string pointers and the mode list pointer into
455 * usable addresses. Print informational messages about the
456 * video adapter and its vendor.
458 if (par
->vbe_ib
.oem_vendor_name_ptr
)
460 ((char *)task
->buf
) + par
->vbe_ib
.oem_vendor_name_ptr
);
462 if (par
->vbe_ib
.oem_product_name_ptr
)
464 ((char *)task
->buf
) + par
->vbe_ib
.oem_product_name_ptr
);
466 if (par
->vbe_ib
.oem_product_rev_ptr
)
468 ((char *)task
->buf
) + par
->vbe_ib
.oem_product_rev_ptr
);
470 if (par
->vbe_ib
.oem_string_ptr
)
472 ((char *)task
->buf
) + par
->vbe_ib
.oem_string_ptr
);
474 printk("VBE v%d.%d\n", ((par
->vbe_ib
.vbe_version
& 0xff00) >> 8),
475 par
->vbe_ib
.vbe_version
& 0xff);
480 static int __devinit
uvesafb_vbe_getmodes(struct uvesafb_ktask
*task
,
481 struct uvesafb_par
*par
)
486 par
->vbe_modes_cnt
= 0;
488 /* Count available modes. */
489 mode
= (u16
*) (((u8
*)&par
->vbe_ib
) + par
->vbe_ib
.mode_list_ptr
);
490 while (*mode
!= 0xffff) {
491 par
->vbe_modes_cnt
++;
495 par
->vbe_modes
= kzalloc(sizeof(struct vbe_mode_ib
) *
496 par
->vbe_modes_cnt
, GFP_KERNEL
);
500 /* Get info about all available modes. */
501 mode
= (u16
*) (((u8
*)&par
->vbe_ib
) + par
->vbe_ib
.mode_list_ptr
);
502 while (*mode
!= 0xffff) {
503 struct vbe_mode_ib
*mib
;
506 task
->t
.regs
.eax
= 0x4f01;
507 task
->t
.regs
.ecx
= (u32
) *mode
;
508 task
->t
.flags
= TF_BUF_RET
| TF_BUF_ESDI
;
509 task
->t
.buf_len
= sizeof(struct vbe_mode_ib
);
510 task
->buf
= par
->vbe_modes
+ off
;
512 err
= uvesafb_exec(task
);
513 if (err
|| (task
->t
.regs
.eax
& 0xffff) != 0x004f) {
514 printk(KERN_WARNING
"uvesafb: Getting mode info block "
515 "for mode 0x%x failed (eax=0x%x, err=%d)\n",
516 *mode
, (u32
)task
->t
.regs
.eax
, err
);
518 par
->vbe_modes_cnt
--;
523 mib
->mode_id
= *mode
;
526 * We only want modes that are supported with the current
527 * hardware configuration, color, graphics and that have
528 * support for the LFB.
530 if ((mib
->mode_attr
& VBE_MODE_MASK
) == VBE_MODE_MASK
&&
531 mib
->bits_per_pixel
>= 8)
534 par
->vbe_modes_cnt
--;
537 mib
->depth
= mib
->red_len
+ mib
->green_len
+ mib
->blue_len
;
540 * Handle 8bpp modes and modes with broken color component
543 if (mib
->depth
== 0 || (mib
->depth
== 24 &&
544 mib
->bits_per_pixel
== 32))
545 mib
->depth
= mib
->bits_per_pixel
;
548 if (par
->vbe_modes_cnt
> 0)
555 * The Protected Mode Interface is 32-bit x86 code, so we only run it on
556 * x86 and not x86_64.
559 static int __devinit
uvesafb_vbe_getpmi(struct uvesafb_ktask
*task
,
560 struct uvesafb_par
*par
)
565 task
->t
.regs
.eax
= 0x4f0a;
566 task
->t
.regs
.ebx
= 0x0;
567 err
= uvesafb_exec(task
);
569 if ((task
->t
.regs
.eax
& 0xffff) != 0x4f || task
->t
.regs
.es
< 0xc000) {
570 par
->pmi_setpal
= par
->ypan
= 0;
572 par
->pmi_base
= (u16
*)phys_to_virt(((u32
)task
->t
.regs
.es
<< 4)
574 par
->pmi_start
= (u8
*)par
->pmi_base
+ par
->pmi_base
[1];
575 par
->pmi_pal
= (u8
*)par
->pmi_base
+ par
->pmi_base
[2];
576 printk(KERN_INFO
"uvesafb: protected mode interface info at "
578 (u16
)task
->t
.regs
.es
, (u16
)task
->t
.regs
.edi
);
579 printk(KERN_INFO
"uvesafb: pmi: set display start = %p, "
580 "set palette = %p\n", par
->pmi_start
,
583 if (par
->pmi_base
[3]) {
584 printk(KERN_INFO
"uvesafb: pmi: ports = ");
585 for (i
= par
->pmi_base
[3]/2;
586 par
->pmi_base
[i
] != 0xffff; i
++)
587 printk("%x ", par
->pmi_base
[i
]);
590 if (par
->pmi_base
[i
] != 0xffff) {
591 printk(KERN_INFO
"uvesafb: can't handle memory"
592 " requests, pmi disabled\n");
593 par
->ypan
= par
->pmi_setpal
= 0;
599 #endif /* CONFIG_X86_32 */
602 * Check whether a video mode is supported by the Video BIOS and is
603 * compatible with the monitor limits.
605 static int __devinit
uvesafb_is_valid_mode(struct fb_videomode
*mode
,
606 struct fb_info
*info
)
608 if (info
->monspecs
.gtf
) {
609 fb_videomode_to_var(&info
->var
, mode
);
610 if (fb_validate_mode(&info
->var
, info
))
614 if (uvesafb_vbe_find_mode(info
->par
, mode
->xres
, mode
->yres
, 8,
615 UVESAFB_EXACT_RES
) == -1)
621 static int __devinit
uvesafb_vbe_getedid(struct uvesafb_ktask
*task
,
622 struct fb_info
*info
)
624 struct uvesafb_par
*par
= info
->par
;
627 if (noedid
|| par
->vbe_ib
.vbe_version
< 0x0300)
630 task
->t
.regs
.eax
= 0x4f15;
631 task
->t
.regs
.ebx
= 0;
632 task
->t
.regs
.ecx
= 0;
636 err
= uvesafb_exec(task
);
638 if ((task
->t
.regs
.eax
& 0xffff) != 0x004f || err
)
641 if ((task
->t
.regs
.ebx
& 0x3) == 3) {
642 printk(KERN_INFO
"uvesafb: VBIOS/hardware supports both "
643 "DDC1 and DDC2 transfers\n");
644 } else if ((task
->t
.regs
.ebx
& 0x3) == 2) {
645 printk(KERN_INFO
"uvesafb: VBIOS/hardware supports DDC2 "
647 } else if ((task
->t
.regs
.ebx
& 0x3) == 1) {
648 printk(KERN_INFO
"uvesafb: VBIOS/hardware supports DDC1 "
651 printk(KERN_INFO
"uvesafb: VBIOS/hardware doesn't support "
656 task
->t
.regs
.eax
= 0x4f15;
657 task
->t
.regs
.ebx
= 1;
658 task
->t
.regs
.ecx
= task
->t
.regs
.edx
= 0;
659 task
->t
.flags
= TF_BUF_RET
| TF_BUF_ESDI
;
660 task
->t
.buf_len
= EDID_LENGTH
;
661 task
->buf
= kzalloc(EDID_LENGTH
, GFP_KERNEL
);
665 err
= uvesafb_exec(task
);
667 if ((task
->t
.regs
.eax
& 0xffff) == 0x004f && !err
) {
668 fb_edid_to_monspecs(task
->buf
, &info
->monspecs
);
670 if (info
->monspecs
.vfmax
&& info
->monspecs
.hfmax
) {
672 * If the maximum pixel clock wasn't specified in
673 * the EDID block, set it to 300 MHz.
675 if (info
->monspecs
.dclkmax
== 0)
676 info
->monspecs
.dclkmax
= 300 * 1000000;
677 info
->monspecs
.gtf
= 1;
687 static void __devinit
uvesafb_vbe_getmonspecs(struct uvesafb_ktask
*task
,
688 struct fb_info
*info
)
690 struct uvesafb_par
*par
= info
->par
;
693 memset(&info
->monspecs
, 0, sizeof(info
->monspecs
));
696 * If we don't get all necessary data from the EDID block,
697 * mark it as incompatible with the GTF and set nocrtc so
698 * that we always use the default BIOS refresh rate.
700 if (uvesafb_vbe_getedid(task
, info
)) {
701 info
->monspecs
.gtf
= 0;
705 /* Kernel command line overrides. */
707 info
->monspecs
.dclkmax
= maxclk
* 1000000;
709 info
->monspecs
.vfmax
= maxvf
;
711 info
->monspecs
.hfmax
= maxhf
* 1000;
714 * In case DDC transfers are not supported, the user can provide
715 * monitor limits manually. Lower limits are set to "safe" values.
717 if (info
->monspecs
.gtf
== 0 && maxclk
&& maxvf
&& maxhf
) {
718 info
->monspecs
.dclkmin
= 0;
719 info
->monspecs
.vfmin
= 60;
720 info
->monspecs
.hfmin
= 29000;
721 info
->monspecs
.gtf
= 1;
725 if (info
->monspecs
.gtf
)
727 "uvesafb: monitor limits: vf = %d Hz, hf = %d kHz, "
728 "clk = %d MHz\n", info
->monspecs
.vfmax
,
729 (int)(info
->monspecs
.hfmax
/ 1000),
730 (int)(info
->monspecs
.dclkmax
/ 1000000));
732 printk(KERN_INFO
"uvesafb: no monitor limits have been set, "
733 "default refresh rate will be used\n");
735 /* Add VBE modes to the modelist. */
736 for (i
= 0; i
< par
->vbe_modes_cnt
; i
++) {
737 struct fb_var_screeninfo var
;
738 struct vbe_mode_ib
*mode
;
739 struct fb_videomode vmode
;
741 mode
= &par
->vbe_modes
[i
];
742 memset(&var
, 0, sizeof(var
));
744 var
.xres
= mode
->x_res
;
745 var
.yres
= mode
->y_res
;
747 fb_get_mode(FB_VSYNCTIMINGS
| FB_IGNOREMON
, 60, &var
, info
);
748 fb_var_to_videomode(&vmode
, &var
);
749 fb_add_videomode(&vmode
, &info
->modelist
);
752 /* Add valid VESA modes to our modelist. */
753 for (i
= 0; i
< VESA_MODEDB_SIZE
; i
++) {
754 if (uvesafb_is_valid_mode((struct fb_videomode
*)
755 &vesa_modes
[i
], info
))
756 fb_add_videomode(&vesa_modes
[i
], &info
->modelist
);
759 for (i
= 0; i
< info
->monspecs
.modedb_len
; i
++) {
760 if (uvesafb_is_valid_mode(&info
->monspecs
.modedb
[i
], info
))
761 fb_add_videomode(&info
->monspecs
.modedb
[i
],
768 static void __devinit
uvesafb_vbe_getstatesize(struct uvesafb_ktask
*task
,
769 struct uvesafb_par
*par
)
776 * Get the VBE state buffer size. We want all available
777 * hardware state data (CL = 0x0f).
779 task
->t
.regs
.eax
= 0x4f04;
780 task
->t
.regs
.ecx
= 0x000f;
781 task
->t
.regs
.edx
= 0x0000;
784 err
= uvesafb_exec(task
);
786 if (err
|| (task
->t
.regs
.eax
& 0xffff) != 0x004f) {
787 printk(KERN_WARNING
"uvesafb: VBE state buffer size "
788 "cannot be determined (eax=0x%x, err=%d)\n",
789 task
->t
.regs
.eax
, err
);
790 par
->vbe_state_size
= 0;
794 par
->vbe_state_size
= 64 * (task
->t
.regs
.ebx
& 0xffff);
797 static int __devinit
uvesafb_vbe_init(struct fb_info
*info
)
799 struct uvesafb_ktask
*task
= NULL
;
800 struct uvesafb_par
*par
= info
->par
;
803 task
= uvesafb_prep();
807 err
= uvesafb_vbe_getinfo(task
, par
);
811 err
= uvesafb_vbe_getmodes(task
, par
);
815 par
->nocrtc
= nocrtc
;
817 par
->pmi_setpal
= pmi_setpal
;
820 if (par
->pmi_setpal
|| par
->ypan
) {
821 if (__supported_pte_mask
& _PAGE_NX
) {
822 par
->pmi_setpal
= par
->ypan
= 0;
823 printk(KERN_WARNING
"uvesafb: NX protection is actively."
824 "We have better not to use the PMI.\n");
826 uvesafb_vbe_getpmi(task
, par
);
830 /* The protected mode interface is not available on non-x86. */
831 par
->pmi_setpal
= par
->ypan
= 0;
834 INIT_LIST_HEAD(&info
->modelist
);
835 uvesafb_vbe_getmonspecs(task
, info
);
836 uvesafb_vbe_getstatesize(task
, par
);
838 out
: uvesafb_free(task
);
842 static int __devinit
uvesafb_vbe_init_mode(struct fb_info
*info
)
844 struct list_head
*pos
;
845 struct fb_modelist
*modelist
;
846 struct fb_videomode
*mode
;
847 struct uvesafb_par
*par
= info
->par
;
850 /* Has the user requested a specific VESA mode? */
852 for (i
= 0; i
< par
->vbe_modes_cnt
; i
++) {
853 if (par
->vbe_modes
[i
].mode_id
== vbemode
) {
855 uvesafb_setup_var(&info
->var
, info
,
856 &par
->vbe_modes
[modeid
]);
857 fb_get_mode(FB_VSYNCTIMINGS
| FB_IGNOREMON
, 60,
860 * With pixclock set to 0, the default BIOS
861 * timings will be used in set_par().
863 info
->var
.pixclock
= 0;
867 printk(KERN_INFO
"uvesafb: requested VBE mode 0x%x is "
868 "unavailable\n", vbemode
);
872 /* Count the modes in the modelist */
874 list_for_each(pos
, &info
->modelist
)
878 * Convert the modelist into a modedb so that we can use it with
881 mode
= kzalloc(i
* sizeof(*mode
), GFP_KERNEL
);
884 list_for_each(pos
, &info
->modelist
) {
885 modelist
= list_entry(pos
, struct fb_modelist
, list
);
886 mode
[i
] = modelist
->mode
;
891 mode_option
= UVESAFB_DEFAULT_MODE
;
893 i
= fb_find_mode(&info
->var
, info
, mode_option
, mode
, i
,
899 /* fb_find_mode() failed */
901 info
->var
.xres
= 640;
902 info
->var
.yres
= 480;
903 mode
= (struct fb_videomode
*)
904 fb_find_best_mode(&info
->var
, &info
->modelist
);
907 fb_videomode_to_var(&info
->var
, mode
);
909 modeid
= par
->vbe_modes
[0].mode_id
;
910 uvesafb_setup_var(&info
->var
, info
,
911 &par
->vbe_modes
[modeid
]);
912 fb_get_mode(FB_VSYNCTIMINGS
| FB_IGNOREMON
, 60,
919 /* Look for a matching VBE mode. */
920 modeid
= uvesafb_vbe_find_mode(par
, info
->var
.xres
, info
->var
.yres
,
921 info
->var
.bits_per_pixel
, UVESAFB_EXACT_RES
);
926 uvesafb_setup_var(&info
->var
, info
, &par
->vbe_modes
[modeid
]);
930 * If we are not VBE3.0+ compliant, we're done -- the BIOS will
931 * ignore our timings anyway.
933 if (par
->vbe_ib
.vbe_version
< 0x0300 || par
->nocrtc
)
934 fb_get_mode(FB_VSYNCTIMINGS
| FB_IGNOREMON
, 60,
940 static int uvesafb_setpalette(struct uvesafb_pal_entry
*entries
, int count
,
941 int start
, struct fb_info
*info
)
943 struct uvesafb_ktask
*task
;
945 struct uvesafb_par
*par
= info
->par
;
946 int i
= par
->mode_idx
;
951 * We support palette modifications for 8 bpp modes only, so
952 * there can never be more than 256 entries.
954 if (start
+ count
> 256)
958 /* Use VGA registers if mode is VGA-compatible. */
959 if (i
>= 0 && i
< par
->vbe_modes_cnt
&&
960 par
->vbe_modes
[i
].mode_attr
& VBE_MODE_VGACOMPAT
) {
961 for (i
= 0; i
< count
; i
++) {
962 outb_p(start
+ i
, dac_reg
);
963 outb_p(entries
[i
].red
, dac_val
);
964 outb_p(entries
[i
].green
, dac_val
);
965 outb_p(entries
[i
].blue
, dac_val
);
969 else if (par
->pmi_setpal
) {
970 __asm__
__volatile__(
972 : /* no return value */
973 : "a" (0x4f09), /* EAX */
975 "c" (count
), /* ECX */
976 "d" (start
), /* EDX */
977 "D" (entries
), /* EDI */
978 "S" (&par
->pmi_pal
)); /* ESI */
980 #endif /* CONFIG_X86_32 */
982 #endif /* CONFIG_X86 */
984 task
= uvesafb_prep();
988 task
->t
.regs
.eax
= 0x4f09;
989 task
->t
.regs
.ebx
= 0x0;
990 task
->t
.regs
.ecx
= count
;
991 task
->t
.regs
.edx
= start
;
992 task
->t
.flags
= TF_BUF_ESDI
;
993 task
->t
.buf_len
= sizeof(struct uvesafb_pal_entry
) * count
;
996 err
= uvesafb_exec(task
);
997 if ((task
->t
.regs
.eax
& 0xffff) != 0x004f)
1005 static int uvesafb_setcolreg(unsigned regno
, unsigned red
, unsigned green
,
1006 unsigned blue
, unsigned transp
,
1007 struct fb_info
*info
)
1009 struct uvesafb_pal_entry entry
;
1010 int shift
= 16 - dac_width
;
1013 if (regno
>= info
->cmap
.len
)
1016 if (info
->var
.bits_per_pixel
== 8) {
1017 entry
.red
= red
>> shift
;
1018 entry
.green
= green
>> shift
;
1019 entry
.blue
= blue
>> shift
;
1022 err
= uvesafb_setpalette(&entry
, 1, regno
, info
);
1023 } else if (regno
< 16) {
1024 switch (info
->var
.bits_per_pixel
) {
1026 if (info
->var
.red
.offset
== 10) {
1028 ((u32
*) (info
->pseudo_palette
))[regno
] =
1029 ((red
& 0xf800) >> 1) |
1030 ((green
& 0xf800) >> 6) |
1031 ((blue
& 0xf800) >> 11);
1034 ((u32
*) (info
->pseudo_palette
))[regno
] =
1036 ((green
& 0xfc00) >> 5) |
1037 ((blue
& 0xf800) >> 11);
1046 ((u32
*)(info
->pseudo_palette
))[regno
] =
1047 (red
<< info
->var
.red
.offset
) |
1048 (green
<< info
->var
.green
.offset
) |
1049 (blue
<< info
->var
.blue
.offset
);
1056 static int uvesafb_setcmap(struct fb_cmap
*cmap
, struct fb_info
*info
)
1058 struct uvesafb_pal_entry
*entries
;
1059 int shift
= 16 - dac_width
;
1062 if (info
->var
.bits_per_pixel
== 8) {
1063 if (cmap
->start
+ cmap
->len
> info
->cmap
.start
+
1064 info
->cmap
.len
|| cmap
->start
< info
->cmap
.start
)
1067 entries
= kmalloc(sizeof(*entries
) * cmap
->len
, GFP_KERNEL
);
1071 for (i
= 0; i
< cmap
->len
; i
++) {
1072 entries
[i
].red
= cmap
->red
[i
] >> shift
;
1073 entries
[i
].green
= cmap
->green
[i
] >> shift
;
1074 entries
[i
].blue
= cmap
->blue
[i
] >> shift
;
1077 err
= uvesafb_setpalette(entries
, cmap
->len
, cmap
->start
, info
);
1081 * For modes with bpp > 8, we only set the pseudo palette in
1082 * the fb_info struct. We rely on uvesafb_setcolreg to do all
1085 for (i
= 0; i
< cmap
->len
; i
++) {
1086 err
|= uvesafb_setcolreg(cmap
->start
+ i
, cmap
->red
[i
],
1087 cmap
->green
[i
], cmap
->blue
[i
],
1094 static int uvesafb_pan_display(struct fb_var_screeninfo
*var
,
1095 struct fb_info
*info
)
1097 #ifdef CONFIG_X86_32
1099 struct uvesafb_par
*par
= info
->par
;
1101 offset
= (var
->yoffset
* info
->fix
.line_length
+ var
->xoffset
) / 4;
1104 * It turns out it's not the best idea to do panning via vm86,
1105 * so we only allow it if we have a PMI.
1107 if (par
->pmi_start
) {
1108 __asm__
__volatile__(
1110 : /* no return value */
1111 : "a" (0x4f07), /* EAX */
1113 "c" (offset
), /* ECX */
1114 "d" (offset
>> 16), /* EDX */
1115 "D" (&par
->pmi_start
)); /* EDI */
1121 static int uvesafb_blank(int blank
, struct fb_info
*info
)
1123 struct uvesafb_ktask
*task
;
1126 struct uvesafb_par
*par
= info
->par
;
1128 if (par
->vbe_ib
.capabilities
& VBE_CAP_VGACOMPAT
) {
1130 u8 seq
= 0, crtc17
= 0;
1132 if (blank
== FB_BLANK_POWERDOWN
) {
1139 err
= (blank
== FB_BLANK_UNBLANK
) ? 0 : -EINVAL
;
1142 vga_wseq(NULL
, 0x00, 0x01);
1143 seq
|= vga_rseq(NULL
, 0x01) & ~0x20;
1144 vga_wseq(NULL
, 0x00, seq
);
1146 crtc17
|= vga_rcrt(NULL
, 0x17) & ~0x80;
1148 vga_wcrt(NULL
, 0x17, crtc17
);
1149 vga_wseq(NULL
, 0x00, 0x03);
1151 #endif /* CONFIG_X86 */
1153 task
= uvesafb_prep();
1157 task
->t
.regs
.eax
= 0x4f10;
1159 case FB_BLANK_UNBLANK
:
1160 task
->t
.regs
.ebx
= 0x0001;
1162 case FB_BLANK_NORMAL
:
1163 task
->t
.regs
.ebx
= 0x0101; /* standby */
1165 case FB_BLANK_POWERDOWN
:
1166 task
->t
.regs
.ebx
= 0x0401; /* powerdown */
1172 err
= uvesafb_exec(task
);
1173 if (err
|| (task
->t
.regs
.eax
& 0xffff) != 0x004f)
1175 out
: uvesafb_free(task
);
1180 static int uvesafb_open(struct fb_info
*info
, int user
)
1182 struct uvesafb_par
*par
= info
->par
;
1183 int cnt
= atomic_read(&par
->ref_count
);
1186 if (!cnt
&& par
->vbe_state_size
) {
1187 buf
= uvesafb_vbe_state_save(par
);
1189 printk(KERN_WARNING
"uvesafb: save hardware state"
1190 "failed, error code is %ld!\n", PTR_ERR(buf
));
1192 par
->vbe_state_orig
= buf
;
1196 atomic_inc(&par
->ref_count
);
1200 static int uvesafb_release(struct fb_info
*info
, int user
)
1202 struct uvesafb_ktask
*task
= NULL
;
1203 struct uvesafb_par
*par
= info
->par
;
1204 int cnt
= atomic_read(&par
->ref_count
);
1212 task
= uvesafb_prep();
1216 /* First, try to set the standard 80x25 text mode. */
1217 task
->t
.regs
.eax
= 0x0003;
1221 * Now try to restore whatever hardware state we might have
1222 * saved when the fb device was first opened.
1224 uvesafb_vbe_state_restore(par
, par
->vbe_state_orig
);
1226 atomic_dec(&par
->ref_count
);
1232 static int uvesafb_set_par(struct fb_info
*info
)
1234 struct uvesafb_par
*par
= info
->par
;
1235 struct uvesafb_ktask
*task
= NULL
;
1236 struct vbe_crtc_ib
*crtc
= NULL
;
1237 struct vbe_mode_ib
*mode
= NULL
;
1238 int i
, err
= 0, depth
= info
->var
.bits_per_pixel
;
1240 if (depth
> 8 && depth
!= 32)
1241 depth
= info
->var
.red
.length
+ info
->var
.green
.length
+
1242 info
->var
.blue
.length
;
1244 i
= uvesafb_vbe_find_mode(par
, info
->var
.xres
, info
->var
.yres
, depth
,
1245 UVESAFB_EXACT_RES
| UVESAFB_EXACT_DEPTH
);
1247 mode
= &par
->vbe_modes
[i
];
1251 task
= uvesafb_prep();
1255 task
->t
.regs
.eax
= 0x4f02;
1256 task
->t
.regs
.ebx
= mode
->mode_id
| 0x4000; /* use LFB */
1258 if (par
->vbe_ib
.vbe_version
>= 0x0300 && !par
->nocrtc
&&
1259 info
->var
.pixclock
!= 0) {
1260 task
->t
.regs
.ebx
|= 0x0800; /* use CRTC data */
1261 task
->t
.flags
= TF_BUF_ESDI
;
1262 crtc
= kzalloc(sizeof(struct vbe_crtc_ib
), GFP_KERNEL
);
1267 crtc
->horiz_start
= info
->var
.xres
+ info
->var
.right_margin
;
1268 crtc
->horiz_end
= crtc
->horiz_start
+ info
->var
.hsync_len
;
1269 crtc
->horiz_total
= crtc
->horiz_end
+ info
->var
.left_margin
;
1271 crtc
->vert_start
= info
->var
.yres
+ info
->var
.lower_margin
;
1272 crtc
->vert_end
= crtc
->vert_start
+ info
->var
.vsync_len
;
1273 crtc
->vert_total
= crtc
->vert_end
+ info
->var
.upper_margin
;
1275 crtc
->pixel_clock
= PICOS2KHZ(info
->var
.pixclock
) * 1000;
1276 crtc
->refresh_rate
= (u16
)(100 * (crtc
->pixel_clock
/
1277 (crtc
->vert_total
* crtc
->horiz_total
)));
1279 if (info
->var
.vmode
& FB_VMODE_DOUBLE
)
1281 if (info
->var
.vmode
& FB_VMODE_INTERLACED
)
1283 if (!(info
->var
.sync
& FB_SYNC_HOR_HIGH_ACT
))
1285 if (!(info
->var
.sync
& FB_SYNC_VERT_HIGH_ACT
))
1287 memcpy(&par
->crtc
, crtc
, sizeof(*crtc
));
1289 memset(&par
->crtc
, 0, sizeof(*crtc
));
1292 task
->t
.buf_len
= sizeof(struct vbe_crtc_ib
);
1293 task
->buf
= &par
->crtc
;
1295 err
= uvesafb_exec(task
);
1296 if (err
|| (task
->t
.regs
.eax
& 0xffff) != 0x004f) {
1298 * The mode switch might have failed because we tried to
1299 * use our own timings. Try again with the default timings.
1302 printk(KERN_WARNING
"uvesafb: mode switch failed "
1303 "(eax=0x%x, err=%d). Trying again with "
1304 "default timings.\n", task
->t
.regs
.eax
, err
);
1305 uvesafb_reset(task
);
1308 info
->var
.pixclock
= 0;
1311 printk(KERN_ERR
"uvesafb: mode switch failed (eax="
1312 "0x%x, err=%d)\n", task
->t
.regs
.eax
, err
);
1319 /* For 8bpp modes, always try to set the DAC to 8 bits. */
1320 if (par
->vbe_ib
.capabilities
& VBE_CAP_CAN_SWITCH_DAC
&&
1321 mode
->bits_per_pixel
<= 8) {
1322 uvesafb_reset(task
);
1323 task
->t
.regs
.eax
= 0x4f08;
1324 task
->t
.regs
.ebx
= 0x0800;
1326 err
= uvesafb_exec(task
);
1327 if (err
|| (task
->t
.regs
.eax
& 0xffff) != 0x004f ||
1328 ((task
->t
.regs
.ebx
& 0xff00) >> 8) != 8) {
1335 info
->fix
.visual
= (info
->var
.bits_per_pixel
== 8) ?
1336 FB_VISUAL_PSEUDOCOLOR
: FB_VISUAL_TRUECOLOR
;
1337 info
->fix
.line_length
= mode
->bytes_per_scan_line
;
1339 out
: if (crtc
!= NULL
)
1346 static void uvesafb_check_limits(struct fb_var_screeninfo
*var
,
1347 struct fb_info
*info
)
1349 const struct fb_videomode
*mode
;
1350 struct uvesafb_par
*par
= info
->par
;
1353 * If pixclock is set to 0, then we're using default BIOS timings
1354 * and thus don't have to perform any checks here.
1359 if (par
->vbe_ib
.vbe_version
< 0x0300) {
1360 fb_get_mode(FB_VSYNCTIMINGS
| FB_IGNOREMON
, 60, var
, info
);
1364 if (!fb_validate_mode(var
, info
))
1367 mode
= fb_find_best_mode(var
, &info
->modelist
);
1369 if (mode
->xres
== var
->xres
&& mode
->yres
== var
->yres
&&
1370 !(mode
->vmode
& (FB_VMODE_INTERLACED
| FB_VMODE_DOUBLE
))) {
1371 fb_videomode_to_var(var
, mode
);
1376 if (info
->monspecs
.gtf
&& !fb_get_mode(FB_MAXTIMINGS
, 0, var
, info
))
1378 /* Use default refresh rate */
1382 static int uvesafb_check_var(struct fb_var_screeninfo
*var
,
1383 struct fb_info
*info
)
1385 struct uvesafb_par
*par
= info
->par
;
1386 struct vbe_mode_ib
*mode
= NULL
;
1388 int depth
= var
->red
.length
+ var
->green
.length
+ var
->blue
.length
;
1391 * Various apps will use bits_per_pixel to set the color depth,
1392 * which is theoretically incorrect, but which we'll try to handle
1395 if (depth
== 0 || abs(depth
- var
->bits_per_pixel
) >= 8)
1396 depth
= var
->bits_per_pixel
;
1398 match
= uvesafb_vbe_find_mode(par
, var
->xres
, var
->yres
, depth
,
1403 mode
= &par
->vbe_modes
[match
];
1404 uvesafb_setup_var(var
, info
, mode
);
1407 * Check whether we have remapped enough memory for this mode.
1408 * We might be called at an early stage, when we haven't remapped
1409 * any memory yet, in which case we simply skip the check.
1411 if (var
->yres
* mode
->bytes_per_scan_line
> info
->fix
.smem_len
1412 && info
->fix
.smem_len
)
1415 if ((var
->vmode
& FB_VMODE_DOUBLE
) &&
1416 !(par
->vbe_modes
[match
].mode_attr
& 0x100))
1417 var
->vmode
&= ~FB_VMODE_DOUBLE
;
1419 if ((var
->vmode
& FB_VMODE_INTERLACED
) &&
1420 !(par
->vbe_modes
[match
].mode_attr
& 0x200))
1421 var
->vmode
&= ~FB_VMODE_INTERLACED
;
1423 uvesafb_check_limits(var
, info
);
1425 var
->xres_virtual
= var
->xres
;
1426 var
->yres_virtual
= (par
->ypan
) ?
1427 info
->fix
.smem_len
/ mode
->bytes_per_scan_line
:
1432 static struct fb_ops uvesafb_ops
= {
1433 .owner
= THIS_MODULE
,
1434 .fb_open
= uvesafb_open
,
1435 .fb_release
= uvesafb_release
,
1436 .fb_setcolreg
= uvesafb_setcolreg
,
1437 .fb_setcmap
= uvesafb_setcmap
,
1438 .fb_pan_display
= uvesafb_pan_display
,
1439 .fb_blank
= uvesafb_blank
,
1440 .fb_fillrect
= cfb_fillrect
,
1441 .fb_copyarea
= cfb_copyarea
,
1442 .fb_imageblit
= cfb_imageblit
,
1443 .fb_check_var
= uvesafb_check_var
,
1444 .fb_set_par
= uvesafb_set_par
,
1447 static void __devinit
uvesafb_init_info(struct fb_info
*info
,
1448 struct vbe_mode_ib
*mode
)
1450 unsigned int size_vmode
;
1451 unsigned int size_remap
;
1452 unsigned int size_total
;
1453 struct uvesafb_par
*par
= info
->par
;
1456 info
->pseudo_palette
= ((u8
*)info
->par
+ sizeof(struct uvesafb_par
));
1457 info
->fix
= uvesafb_fix
;
1458 info
->fix
.ypanstep
= par
->ypan
? 1 : 0;
1459 info
->fix
.ywrapstep
= (par
->ypan
> 1) ? 1 : 0;
1461 /* Disable blanking if the user requested so. */
1463 info
->fbops
->fb_blank
= NULL
;
1466 * Find out how much IO memory is required for the mode with
1467 * the highest resolution.
1470 for (i
= 0; i
< par
->vbe_modes_cnt
; i
++) {
1471 h
= par
->vbe_modes
[i
].bytes_per_scan_line
*
1472 par
->vbe_modes
[i
].y_res
;
1479 * size_vmode -- that is the amount of memory needed for the
1480 * used video mode, i.e. the minimum amount of
1484 size_vmode
= info
->var
.yres
* mode
->bytes_per_scan_line
;
1486 size_vmode
= info
->var
.yres
* info
->var
.xres
*
1487 ((info
->var
.bits_per_pixel
+ 7) >> 3);
1491 * size_total -- all video memory we have. Used for mtrr
1492 * entries, resource allocation and bounds
1495 size_total
= par
->vbe_ib
.total_memory
* 65536;
1497 size_total
= vram_total
* 1024 * 1024;
1498 if (size_total
< size_vmode
)
1499 size_total
= size_vmode
;
1502 * size_remap -- the amount of video memory we are going to
1503 * use for vesafb. With modern cards it is no
1504 * option to simply use size_total as th
1505 * wastes plenty of kernel address space.
1508 size_remap
= vram_remap
* 1024 * 1024;
1509 if (size_remap
< size_vmode
)
1510 size_remap
= size_vmode
;
1511 if (size_remap
> size_total
)
1512 size_remap
= size_total
;
1514 info
->fix
.smem_len
= size_remap
;
1515 info
->fix
.smem_start
= mode
->phys_base_ptr
;
1518 * We have to set yres_virtual here because when setup_var() was
1519 * called, smem_len wasn't defined yet.
1521 info
->var
.yres_virtual
= info
->fix
.smem_len
/
1522 mode
->bytes_per_scan_line
;
1524 if (par
->ypan
&& info
->var
.yres_virtual
> info
->var
.yres
) {
1525 printk(KERN_INFO
"uvesafb: scrolling: %s "
1526 "using protected mode interface, "
1527 "yres_virtual=%d\n",
1528 (par
->ypan
> 1) ? "ywrap" : "ypan",
1529 info
->var
.yres_virtual
);
1531 printk(KERN_INFO
"uvesafb: scrolling: redraw\n");
1532 info
->var
.yres_virtual
= info
->var
.yres
;
1536 info
->flags
= FBINFO_FLAG_DEFAULT
|
1537 (par
->ypan
? FBINFO_HWACCEL_YPAN
: 0);
1540 info
->fbops
->fb_pan_display
= NULL
;
1543 static void __devinit
uvesafb_init_mtrr(struct fb_info
*info
)
1546 if (mtrr
&& !(info
->fix
.smem_start
& (PAGE_SIZE
- 1))) {
1547 int temp_size
= info
->fix
.smem_len
;
1548 unsigned int type
= 0;
1552 type
= MTRR_TYPE_UNCACHABLE
;
1555 type
= MTRR_TYPE_WRBACK
;
1558 type
= MTRR_TYPE_WRCOMB
;
1561 type
= MTRR_TYPE_WRTHROUGH
;
1571 /* Find the largest power-of-two */
1572 temp_size
= roundup_pow_of_two(temp_size
);
1574 /* Try and find a power of two to add */
1576 rc
= mtrr_add(info
->fix
.smem_start
,
1577 temp_size
, type
, 1);
1579 } while (temp_size
>= PAGE_SIZE
&& rc
== -EINVAL
);
1582 #endif /* CONFIG_MTRR */
1585 static void __devinit
uvesafb_ioremap(struct fb_info
*info
)
1589 case 1: /* uncachable */
1590 info
->screen_base
= ioremap_nocache(info
->fix
.smem_start
, info
->fix
.smem_len
);
1592 case 2: /* write-back */
1593 info
->screen_base
= ioremap_cache(info
->fix
.smem_start
, info
->fix
.smem_len
);
1595 case 3: /* write-combining */
1596 info
->screen_base
= ioremap_wc(info
->fix
.smem_start
, info
->fix
.smem_len
);
1598 case 4: /* write-through */
1600 info
->screen_base
= ioremap(info
->fix
.smem_start
, info
->fix
.smem_len
);
1604 info
->screen_base
= ioremap(info
->fix
.smem_start
, info
->fix
.smem_len
);
1605 #endif /* CONFIG_X86 */
1608 static ssize_t
uvesafb_show_vbe_ver(struct device
*dev
,
1609 struct device_attribute
*attr
, char *buf
)
1611 struct fb_info
*info
= platform_get_drvdata(to_platform_device(dev
));
1612 struct uvesafb_par
*par
= info
->par
;
1614 return snprintf(buf
, PAGE_SIZE
, "%.4x\n", par
->vbe_ib
.vbe_version
);
1617 static DEVICE_ATTR(vbe_version
, S_IRUGO
, uvesafb_show_vbe_ver
, NULL
);
1619 static ssize_t
uvesafb_show_vbe_modes(struct device
*dev
,
1620 struct device_attribute
*attr
, char *buf
)
1622 struct fb_info
*info
= platform_get_drvdata(to_platform_device(dev
));
1623 struct uvesafb_par
*par
= info
->par
;
1626 for (i
= 0; i
< par
->vbe_modes_cnt
&& ret
< PAGE_SIZE
; i
++) {
1627 ret
+= snprintf(buf
+ ret
, PAGE_SIZE
- ret
,
1628 "%dx%d-%d, 0x%.4x\n",
1629 par
->vbe_modes
[i
].x_res
, par
->vbe_modes
[i
].y_res
,
1630 par
->vbe_modes
[i
].depth
, par
->vbe_modes
[i
].mode_id
);
1636 static DEVICE_ATTR(vbe_modes
, S_IRUGO
, uvesafb_show_vbe_modes
, NULL
);
1638 static ssize_t
uvesafb_show_vendor(struct device
*dev
,
1639 struct device_attribute
*attr
, char *buf
)
1641 struct fb_info
*info
= platform_get_drvdata(to_platform_device(dev
));
1642 struct uvesafb_par
*par
= info
->par
;
1644 if (par
->vbe_ib
.oem_vendor_name_ptr
)
1645 return snprintf(buf
, PAGE_SIZE
, "%s\n", (char *)
1646 (&par
->vbe_ib
) + par
->vbe_ib
.oem_vendor_name_ptr
);
1651 static DEVICE_ATTR(oem_vendor
, S_IRUGO
, uvesafb_show_vendor
, NULL
);
1653 static ssize_t
uvesafb_show_product_name(struct device
*dev
,
1654 struct device_attribute
*attr
, char *buf
)
1656 struct fb_info
*info
= platform_get_drvdata(to_platform_device(dev
));
1657 struct uvesafb_par
*par
= info
->par
;
1659 if (par
->vbe_ib
.oem_product_name_ptr
)
1660 return snprintf(buf
, PAGE_SIZE
, "%s\n", (char *)
1661 (&par
->vbe_ib
) + par
->vbe_ib
.oem_product_name_ptr
);
1666 static DEVICE_ATTR(oem_product_name
, S_IRUGO
, uvesafb_show_product_name
, NULL
);
1668 static ssize_t
uvesafb_show_product_rev(struct device
*dev
,
1669 struct device_attribute
*attr
, char *buf
)
1671 struct fb_info
*info
= platform_get_drvdata(to_platform_device(dev
));
1672 struct uvesafb_par
*par
= info
->par
;
1674 if (par
->vbe_ib
.oem_product_rev_ptr
)
1675 return snprintf(buf
, PAGE_SIZE
, "%s\n", (char *)
1676 (&par
->vbe_ib
) + par
->vbe_ib
.oem_product_rev_ptr
);
1681 static DEVICE_ATTR(oem_product_rev
, S_IRUGO
, uvesafb_show_product_rev
, NULL
);
1683 static ssize_t
uvesafb_show_oem_string(struct device
*dev
,
1684 struct device_attribute
*attr
, char *buf
)
1686 struct fb_info
*info
= platform_get_drvdata(to_platform_device(dev
));
1687 struct uvesafb_par
*par
= info
->par
;
1689 if (par
->vbe_ib
.oem_string_ptr
)
1690 return snprintf(buf
, PAGE_SIZE
, "%s\n",
1691 (char *)(&par
->vbe_ib
) + par
->vbe_ib
.oem_string_ptr
);
1696 static DEVICE_ATTR(oem_string
, S_IRUGO
, uvesafb_show_oem_string
, NULL
);
1698 static ssize_t
uvesafb_show_nocrtc(struct device
*dev
,
1699 struct device_attribute
*attr
, char *buf
)
1701 struct fb_info
*info
= platform_get_drvdata(to_platform_device(dev
));
1702 struct uvesafb_par
*par
= info
->par
;
1704 return snprintf(buf
, PAGE_SIZE
, "%d\n", par
->nocrtc
);
1707 static ssize_t
uvesafb_store_nocrtc(struct device
*dev
,
1708 struct device_attribute
*attr
, const char *buf
, size_t count
)
1710 struct fb_info
*info
= platform_get_drvdata(to_platform_device(dev
));
1711 struct uvesafb_par
*par
= info
->par
;
1722 static DEVICE_ATTR(nocrtc
, S_IRUGO
| S_IWUSR
, uvesafb_show_nocrtc
,
1723 uvesafb_store_nocrtc
);
1725 static struct attribute
*uvesafb_dev_attrs
[] = {
1726 &dev_attr_vbe_version
.attr
,
1727 &dev_attr_vbe_modes
.attr
,
1728 &dev_attr_oem_vendor
.attr
,
1729 &dev_attr_oem_product_name
.attr
,
1730 &dev_attr_oem_product_rev
.attr
,
1731 &dev_attr_oem_string
.attr
,
1732 &dev_attr_nocrtc
.attr
,
1736 static struct attribute_group uvesafb_dev_attgrp
= {
1738 .attrs
= uvesafb_dev_attrs
,
1741 static int __devinit
uvesafb_probe(struct platform_device
*dev
)
1743 struct fb_info
*info
;
1744 struct vbe_mode_ib
*mode
= NULL
;
1745 struct uvesafb_par
*par
;
1748 info
= framebuffer_alloc(sizeof(*par
) + sizeof(u32
) * 256, &dev
->dev
);
1754 err
= uvesafb_vbe_init(info
);
1756 printk(KERN_ERR
"uvesafb: vbe_init() failed with %d\n", err
);
1760 info
->fbops
= &uvesafb_ops
;
1762 i
= uvesafb_vbe_init_mode(info
);
1767 mode
= &par
->vbe_modes
[i
];
1770 if (fb_alloc_cmap(&info
->cmap
, 256, 0) < 0) {
1775 uvesafb_init_info(info
, mode
);
1777 if (!request_region(0x3c0, 32, "uvesafb")) {
1778 printk(KERN_ERR
"uvesafb: request region 0x3c0-0x3e0 failed\n");
1783 if (!request_mem_region(info
->fix
.smem_start
, info
->fix
.smem_len
,
1785 printk(KERN_ERR
"uvesafb: cannot reserve video memory at "
1786 "0x%lx\n", info
->fix
.smem_start
);
1791 uvesafb_init_mtrr(info
);
1792 uvesafb_ioremap(info
);
1794 if (!info
->screen_base
) {
1796 "uvesafb: abort, cannot ioremap 0x%x bytes of video "
1797 "memory at 0x%lx\n",
1798 info
->fix
.smem_len
, info
->fix
.smem_start
);
1803 platform_set_drvdata(dev
, info
);
1805 if (register_framebuffer(info
) < 0) {
1807 "uvesafb: failed to register framebuffer device\n");
1812 printk(KERN_INFO
"uvesafb: framebuffer at 0x%lx, mapped to 0x%p, "
1813 "using %dk, total %dk\n", info
->fix
.smem_start
,
1814 info
->screen_base
, info
->fix
.smem_len
/1024,
1815 par
->vbe_ib
.total_memory
* 64);
1816 printk(KERN_INFO
"fb%d: %s frame buffer device\n", info
->node
,
1819 err
= sysfs_create_group(&dev
->dev
.kobj
, &uvesafb_dev_attgrp
);
1821 printk(KERN_WARNING
"fb%d: failed to register attributes\n",
1827 iounmap(info
->screen_base
);
1829 release_mem_region(info
->fix
.smem_start
, info
->fix
.smem_len
);
1831 release_region(0x3c0, 32);
1833 if (!list_empty(&info
->modelist
))
1834 fb_destroy_modelist(&info
->modelist
);
1835 fb_destroy_modedb(info
->monspecs
.modedb
);
1836 fb_dealloc_cmap(&info
->cmap
);
1839 kfree(par
->vbe_modes
);
1841 framebuffer_release(info
);
1845 static int uvesafb_remove(struct platform_device
*dev
)
1847 struct fb_info
*info
= platform_get_drvdata(dev
);
1850 struct uvesafb_par
*par
= info
->par
;
1852 sysfs_remove_group(&dev
->dev
.kobj
, &uvesafb_dev_attgrp
);
1853 unregister_framebuffer(info
);
1854 release_region(0x3c0, 32);
1855 iounmap(info
->screen_base
);
1856 release_mem_region(info
->fix
.smem_start
, info
->fix
.smem_len
);
1857 fb_destroy_modedb(info
->monspecs
.modedb
);
1858 fb_dealloc_cmap(&info
->cmap
);
1862 kfree(par
->vbe_modes
);
1863 if (par
->vbe_state_orig
)
1864 kfree(par
->vbe_state_orig
);
1865 if (par
->vbe_state_saved
)
1866 kfree(par
->vbe_state_saved
);
1869 framebuffer_release(info
);
1874 static struct platform_driver uvesafb_driver
= {
1875 .probe
= uvesafb_probe
,
1876 .remove
= uvesafb_remove
,
1882 static struct platform_device
*uvesafb_device
;
1885 static int __devinit
uvesafb_setup(char *options
)
1889 if (!options
|| !*options
)
1892 while ((this_opt
= strsep(&options
, ",")) != NULL
) {
1893 if (!*this_opt
) continue;
1895 if (!strcmp(this_opt
, "redraw"))
1897 else if (!strcmp(this_opt
, "ypan"))
1899 else if (!strcmp(this_opt
, "ywrap"))
1901 else if (!strcmp(this_opt
, "vgapal"))
1903 else if (!strcmp(this_opt
, "pmipal"))
1905 else if (!strncmp(this_opt
, "mtrr:", 5))
1906 mtrr
= simple_strtoul(this_opt
+5, NULL
, 0);
1907 else if (!strcmp(this_opt
, "nomtrr"))
1909 else if (!strcmp(this_opt
, "nocrtc"))
1911 else if (!strcmp(this_opt
, "noedid"))
1913 else if (!strcmp(this_opt
, "noblank"))
1915 else if (!strncmp(this_opt
, "vtotal:", 7))
1916 vram_total
= simple_strtoul(this_opt
+ 7, NULL
, 0);
1917 else if (!strncmp(this_opt
, "vremap:", 7))
1918 vram_remap
= simple_strtoul(this_opt
+ 7, NULL
, 0);
1919 else if (!strncmp(this_opt
, "maxhf:", 6))
1920 maxhf
= simple_strtoul(this_opt
+ 6, NULL
, 0);
1921 else if (!strncmp(this_opt
, "maxvf:", 6))
1922 maxvf
= simple_strtoul(this_opt
+ 6, NULL
, 0);
1923 else if (!strncmp(this_opt
, "maxclk:", 7))
1924 maxclk
= simple_strtoul(this_opt
+ 7, NULL
, 0);
1925 else if (!strncmp(this_opt
, "vbemode:", 8))
1926 vbemode
= simple_strtoul(this_opt
+ 8, NULL
, 0);
1927 else if (this_opt
[0] >= '0' && this_opt
[0] <= '9') {
1928 mode_option
= this_opt
;
1931 "uvesafb: unrecognized option %s\n", this_opt
);
1937 #endif /* !MODULE */
1939 static ssize_t
show_v86d(struct device_driver
*dev
, char *buf
)
1941 return snprintf(buf
, PAGE_SIZE
, "%s\n", v86d_path
);
1944 static ssize_t
store_v86d(struct device_driver
*dev
, const char *buf
,
1947 strncpy(v86d_path
, buf
, PATH_MAX
);
1951 static DRIVER_ATTR(v86d
, S_IRUGO
| S_IWUSR
, show_v86d
, store_v86d
);
1953 static int __devinit
uvesafb_init(void)
1958 char *option
= NULL
;
1960 if (fb_get_options("uvesafb", &option
))
1962 uvesafb_setup(option
);
1964 err
= cn_add_callback(&uvesafb_cn_id
, "uvesafb", uvesafb_cn_callback
);
1968 err
= platform_driver_register(&uvesafb_driver
);
1971 uvesafb_device
= platform_device_alloc("uvesafb", 0);
1973 err
= platform_device_add(uvesafb_device
);
1978 platform_device_put(uvesafb_device
);
1979 platform_driver_unregister(&uvesafb_driver
);
1980 cn_del_callback(&uvesafb_cn_id
);
1984 err
= driver_create_file(&uvesafb_driver
.driver
,
1987 printk(KERN_WARNING
"uvesafb: failed to register "
1995 module_init(uvesafb_init
);
1997 static void __devexit
uvesafb_exit(void)
1999 struct uvesafb_ktask
*task
;
2002 task
= uvesafb_prep();
2004 task
->t
.flags
= TF_EXIT
;
2010 cn_del_callback(&uvesafb_cn_id
);
2011 driver_remove_file(&uvesafb_driver
.driver
, &driver_attr_v86d
);
2012 platform_device_unregister(uvesafb_device
);
2013 platform_driver_unregister(&uvesafb_driver
);
2016 module_exit(uvesafb_exit
);
2018 static int param_set_scroll(const char *val
, const struct kernel_param
*kp
)
2022 if (!strcmp(val
, "redraw"))
2024 else if (!strcmp(val
, "ypan"))
2026 else if (!strcmp(val
, "ywrap"))
2033 static struct kernel_param_ops param_ops_scroll
= {
2034 .set
= param_set_scroll
,
2036 #define param_check_scroll(name, p) __param_check(name, p, void)
2038 module_param_named(scroll
, ypan
, scroll
, 0);
2039 MODULE_PARM_DESC(scroll
,
2040 "Scrolling mode, set to 'redraw', 'ypan', or 'ywrap'");
2041 module_param_named(vgapal
, pmi_setpal
, invbool
, 0);
2042 MODULE_PARM_DESC(vgapal
, "Set palette using VGA registers");
2043 module_param_named(pmipal
, pmi_setpal
, bool, 0);
2044 MODULE_PARM_DESC(pmipal
, "Set palette using PMI calls");
2045 module_param(mtrr
, uint
, 0);
2046 MODULE_PARM_DESC(mtrr
,
2047 "Memory Type Range Registers setting. Use 0 to disable.");
2048 module_param(blank
, bool, 0);
2049 MODULE_PARM_DESC(blank
, "Enable hardware blanking");
2050 module_param(nocrtc
, bool, 0);
2051 MODULE_PARM_DESC(nocrtc
, "Ignore CRTC timings when setting modes");
2052 module_param(noedid
, bool, 0);
2053 MODULE_PARM_DESC(noedid
,
2054 "Ignore EDID-provided monitor limits when setting modes");
2055 module_param(vram_remap
, uint
, 0);
2056 MODULE_PARM_DESC(vram_remap
, "Set amount of video memory to be used [MiB]");
2057 module_param(vram_total
, uint
, 0);
2058 MODULE_PARM_DESC(vram_total
, "Set total amount of video memoery [MiB]");
2059 module_param(maxclk
, ushort
, 0);
2060 MODULE_PARM_DESC(maxclk
, "Maximum pixelclock [MHz], overrides EDID data");
2061 module_param(maxhf
, ushort
, 0);
2062 MODULE_PARM_DESC(maxhf
,
2063 "Maximum horizontal frequency [kHz], overrides EDID data");
2064 module_param(maxvf
, ushort
, 0);
2065 MODULE_PARM_DESC(maxvf
,
2066 "Maximum vertical frequency [Hz], overrides EDID data");
2067 module_param(mode_option
, charp
, 0);
2068 MODULE_PARM_DESC(mode_option
,
2069 "Specify initial video mode as \"<xres>x<yres>[-<bpp>][@<refresh>]\"");
2070 module_param(vbemode
, ushort
, 0);
2071 MODULE_PARM_DESC(vbemode
,
2072 "VBE mode number to set, overrides the 'mode' option");
2073 module_param_string(v86d
, v86d_path
, PATH_MAX
, 0660);
2074 MODULE_PARM_DESC(v86d
, "Path to the v86d userspace helper.");
2076 MODULE_LICENSE("GPL");
2077 MODULE_AUTHOR("Michal Januszewski <spock@gentoo.org>");
2078 MODULE_DESCRIPTION("Framebuffer driver for VBE2.0+ compliant graphics boards");