1/* 2 * A framebuffer driver for VBE 2.0+ compliant video cards 3 * 4 * (c) 2007 Michal Januszewski <spock@gentoo.org> 5 * Loosely based upon the vesafb driver. 6 * 7 */ 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> 18#include <linux/fb.h> 19#include <linux/io.h> 20#include <linux/mutex.h> 21#include <linux/slab.h> 22#include <video/edid.h> 23#include <video/uvesafb.h> 24#ifdef CONFIG_X86 25#include <video/vga.h> 26#endif 27#ifdef CONFIG_MTRR 28#include <asm/mtrr.h> 29#endif 30#include "edid.h" 31 32static struct cb_id uvesafb_cn_id = { 33 .idx = CN_IDX_V86D, 34 .val = CN_VAL_V86D_UVESAFB 35}; 36static char v86d_path[PATH_MAX] = "/sbin/v86d"; 37static char v86d_started; /* has v86d been started by uvesafb? */ 38 39static struct fb_fix_screeninfo uvesafb_fix __devinitdata = { 40 .id = "VESA VGA", 41 .type = FB_TYPE_PACKED_PIXELS, 42 .accel = FB_ACCEL_NONE, 43 .visual = FB_VISUAL_TRUECOLOR, 44}; 45 46static int mtrr __devinitdata = 3; /* enable mtrr by default */ 47static int blank = 1; /* enable blanking by default */ 48static int ypan = 1; /* 0: scroll, 1: ypan, 2: ywrap */ 49static bool pmi_setpal __devinitdata = true; /* use PMI for palette changes */ 50static int nocrtc __devinitdata; /* ignore CRTC settings */ 51static int noedid __devinitdata; /* don't try DDC transfers */ 52static int vram_remap __devinitdata; /* set amt. of memory to be used */ 53static int vram_total __devinitdata; /* set total amount of memory */ 54static u16 maxclk __devinitdata; /* maximum pixel clock */ 55static u16 maxvf __devinitdata; /* maximum vertical frequency */ 56static u16 maxhf __devinitdata; /* maximum horizontal frequency */ 57static u16 vbemode __devinitdata; /* force use of a specific VBE mode */ 58static char *mode_option __devinitdata; 59static u8 dac_width = 6; 60 61static struct uvesafb_ktask *uvfb_tasks[UVESAFB_TASKS_MAX]; 62static DEFINE_MUTEX(uvfb_lock); 63 64/* 65 * A handler for replies from userspace. 66 * 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. 70 */ 71static void uvesafb_cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp) 72{ 73 struct uvesafb_task *utask; 74 struct uvesafb_ktask *task; 75 76 if (!cap_raised(nsp->eff_cap, CAP_SYS_ADMIN)) 77 return; 78 79 if (msg->seq >= UVESAFB_TASKS_MAX) 80 return; 81 82 mutex_lock(&uvfb_lock); 83 task = uvfb_tasks[msg->seq]; 84 85 if (!task || msg->ack != task->ack) { 86 mutex_unlock(&uvfb_lock); 87 return; 88 } 89 90 utask = (struct uvesafb_task *)msg->data; 91 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); 96 return; 97 } 98 99 uvfb_tasks[msg->seq] = NULL; 100 mutex_unlock(&uvfb_lock); 101 102 memcpy(&task->t, utask, sizeof(*utask)); 103 104 if (task->t.buf_len && task->buf) 105 memcpy(task->buf, utask + 1, task->t.buf_len); 106 107 complete(task->done); 108 return; 109} 110 111static int uvesafb_helper_start(void) 112{ 113 char *envp[] = { 114 "HOME=/", 115 "PATH=/sbin:/bin", 116 NULL, 117 }; 118 119 char *argv[] = { 120 v86d_path, 121 NULL, 122 }; 123 124 return call_usermodehelper(v86d_path, argv, envp, 1); 125} 126 127/* 128 * Execute a uvesafb task. 129 * 130 * Returns 0 if the task is executed successfully. 131 * 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 136 * the buffer. 137 * 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. 142 */ 143static int uvesafb_exec(struct uvesafb_ktask *task) 144{ 145 static int seq; 146 struct cn_msg *m; 147 int err; 148 int len = sizeof(task->t) + task->t.buf_len; 149 150 /* 151 * Check whether the message isn't longer than the maximum 152 * allowed by connector. 153 */ 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)); 157 return -E2BIG; 158 } 159 160 m = kzalloc(sizeof(*m) + len, GFP_KERNEL); 161 if (!m) 162 return -ENOMEM; 163 164 init_completion(task->done); 165 166 memcpy(&m->id, &uvesafb_cn_id, sizeof(m->id)); 167 m->seq = seq; 168 m->len = len; 169 m->ack = random32(); 170 171 /* uvesafb_task structure */ 172 memcpy(m + 1, &task->t, sizeof(task->t)); 173 174 /* Buffer */ 175 memcpy((u8 *)(m + 1) + sizeof(task->t), task->buf, task->t.buf_len); 176 177 /* 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. 180 */ 181 task->ack = m->ack; 182 183 mutex_lock(&uvfb_lock); 184 185 /* If all slots are taken -- bail out. */ 186 if (uvfb_tasks[seq]) { 187 mutex_unlock(&uvfb_lock); 188 err = -EBUSY; 189 goto out; 190 } 191 192 /* Save a pointer to the kernel part of the task struct. */ 193 uvfb_tasks[seq] = task; 194 mutex_unlock(&uvfb_lock); 195 196 err = cn_netlink_send(m, 0, GFP_KERNEL); 197 if (err == -ESRCH) { 198 /* 199 * Try to start the userspace helper if sending 200 * the request failed the first time. 201 */ 202 err = uvesafb_helper_start(); 203 if (err) { 204 printk(KERN_ERR "uvesafb: failed to execute %s\n", 205 v86d_path); 206 printk(KERN_ERR "uvesafb: make sure that the v86d " 207 "helper is installed and executable\n"); 208 } else { 209 v86d_started = 1; 210 err = cn_netlink_send(m, 0, gfp_any()); 211 if (err == -ENOBUFS) 212 err = 0; 213 } 214 } else if (err == -ENOBUFS) 215 err = 0; 216 217 if (!err && !(task->t.flags & TF_EXIT)) 218 err = !wait_for_completion_timeout(task->done, 219 msecs_to_jiffies(UVESAFB_TIMEOUT)); 220 221 mutex_lock(&uvfb_lock); 222 uvfb_tasks[seq] = NULL; 223 mutex_unlock(&uvfb_lock); 224 225 seq++; 226 if (seq >= UVESAFB_TASKS_MAX) 227 seq = 0; 228out: 229 kfree(m); 230 return err; 231} 232 233/* 234 * Free a uvesafb_ktask struct. 235 */ 236static void uvesafb_free(struct uvesafb_ktask *task) 237{ 238 if (task) { 239 if (task->done) 240 kfree(task->done); 241 kfree(task); 242 } 243} 244 245/* 246 * Prepare a uvesafb_ktask struct to be used again. 247 */ 248static void uvesafb_reset(struct uvesafb_ktask *task) 249{ 250 struct completion *cpl = task->done; 251 252 memset(task, 0, sizeof(*task)); 253 task->done = cpl; 254} 255 256/* 257 * Allocate and prepare a uvesafb_ktask struct. 258 */ 259static struct uvesafb_ktask *uvesafb_prep(void) 260{ 261 struct uvesafb_ktask *task; 262 263 task = kzalloc(sizeof(*task), GFP_KERNEL); 264 if (task) { 265 task->done = kzalloc(sizeof(*task->done), GFP_KERNEL); 266 if (!task->done) { 267 kfree(task); 268 task = NULL; 269 } 270 } 271 return task; 272} 273 274static void uvesafb_setup_var(struct fb_var_screeninfo *var, 275 struct fb_info *info, struct vbe_mode_ib *mode) 276{ 277 struct uvesafb_par *par = info->par; 278 279 var->vmode = FB_VMODE_NONINTERLACED; 280 var->sync = FB_SYNC_VERT_HIGH_ACT; 281 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 : 287 mode->y_res; 288 var->xoffset = 0; 289 var->yoffset = 0; 290 var->bits_per_pixel = mode->bits_per_pixel; 291 292 if (var->bits_per_pixel == 15) 293 var->bits_per_pixel = 16; 294 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; 304 } else { 305 var->red.offset = 0; 306 var->green.offset = 0; 307 var->blue.offset = 0; 308 var->transp.offset = 0; 309 310 var->red.length = 8; 311 var->green.length = 8; 312 var->blue.length = 8; 313 var->transp.length = 0; 314 } 315} 316 317static int uvesafb_vbe_find_mode(struct uvesafb_par *par, 318 int xres, int yres, int depth, unsigned char flags) 319{ 320 int i, match = -1, h = 0, d = 0x7fffffff; 321 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); 326 327 /* 328 * We have an exact match in terms of resolution 329 * and depth. 330 */ 331 if (h == 0) 332 return i; 333 334 if (h < d || (h == d && par->vbe_modes[i].depth > depth)) { 335 d = h; 336 match = i; 337 } 338 } 339 i = 1; 340 341 if (flags & UVESAFB_EXACT_DEPTH && 342 par->vbe_modes[match].depth != depth) 343 i = 0; 344 345 if (flags & UVESAFB_EXACT_RES && d > 24) 346 i = 0; 347 348 if (i != 0) 349 return match; 350 else 351 return -1; 352} 353 354static u8 *uvesafb_vbe_state_save(struct uvesafb_par *par) 355{ 356 struct uvesafb_ktask *task; 357 u8 *state; 358 int err; 359 360 if (!par->vbe_state_size) 361 return NULL; 362 363 state = kmalloc(par->vbe_state_size, GFP_KERNEL); 364 if (!state) 365 return NULL; 366 367 task = uvesafb_prep(); 368 if (!task) { 369 kfree(state); 370 return NULL; 371 } 372 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; 378 task->buf = state; 379 err = uvesafb_exec(task); 380 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); 385 kfree(state); 386 state = NULL; 387 } 388 389 uvesafb_free(task); 390 return state; 391} 392 393static void uvesafb_vbe_state_restore(struct uvesafb_par *par, u8 *state_buf) 394{ 395 struct uvesafb_ktask *task; 396 int err; 397 398 if (!state_buf) 399 return; 400 401 task = uvesafb_prep(); 402 if (!task) 403 return; 404 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; 411 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); 417 418 uvesafb_free(task); 419} 420 421static int __devinit uvesafb_vbe_getinfo(struct uvesafb_ktask *task, 422 struct uvesafb_par *par) 423{ 424 int err; 425 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); 431 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, 436 err); 437 return -EINVAL; 438 } 439 440 if (par->vbe_ib.vbe_version < 0x0200) { 441 printk(KERN_ERR "uvesafb: Sorry, pre-VBE 2.0 cards are " 442 "not supported.\n"); 443 return -EINVAL; 444 } 445 446 if (!par->vbe_ib.mode_list_ptr) { 447 printk(KERN_ERR "uvesafb: Missing mode list!\n"); 448 return -EINVAL; 449 } 450 451 printk(KERN_INFO "uvesafb: "); 452 453 /* 454 * Convert string pointers and the mode list pointer into 455 * usable addresses. Print informational messages about the 456 * video adapter and its vendor. 457 */ 458 if (par->vbe_ib.oem_vendor_name_ptr) 459 printk("%s, ", 460 ((char *)task->buf) + par->vbe_ib.oem_vendor_name_ptr); 461 462 if (par->vbe_ib.oem_product_name_ptr) 463 printk("%s, ", 464 ((char *)task->buf) + par->vbe_ib.oem_product_name_ptr); 465 466 if (par->vbe_ib.oem_product_rev_ptr) 467 printk("%s, ", 468 ((char *)task->buf) + par->vbe_ib.oem_product_rev_ptr); 469 470 if (par->vbe_ib.oem_string_ptr) 471 printk("OEM: %s, ", 472 ((char *)task->buf) + par->vbe_ib.oem_string_ptr); 473 474 printk("VBE v%d.%d\n", ((par->vbe_ib.vbe_version & 0xff00) >> 8), 475 par->vbe_ib.vbe_version & 0xff); 476 477 return 0; 478} 479 480static int __devinit uvesafb_vbe_getmodes(struct uvesafb_ktask *task, 481 struct uvesafb_par *par) 482{ 483 int off = 0, err; 484 u16 *mode; 485 486 par->vbe_modes_cnt = 0; 487 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++; 492 mode++; 493 } 494 495 par->vbe_modes = kzalloc(sizeof(struct vbe_mode_ib) * 496 par->vbe_modes_cnt, GFP_KERNEL); 497 if (!par->vbe_modes) 498 return -ENOMEM; 499 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; 504 505 uvesafb_reset(task); 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; 511 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); 517 mode++; 518 par->vbe_modes_cnt--; 519 continue; 520 } 521 522 mib = task->buf; 523 mib->mode_id = *mode; 524 525 /* 526 * We only want modes that are supported with the current 527 * hardware configuration, color, graphics and that have 528 * support for the LFB. 529 */ 530 if ((mib->mode_attr & VBE_MODE_MASK) == VBE_MODE_MASK && 531 mib->bits_per_pixel >= 8) 532 off++; 533 else 534 par->vbe_modes_cnt--; 535 536 mode++; 537 mib->depth = mib->red_len + mib->green_len + mib->blue_len; 538 539 /* 540 * Handle 8bpp modes and modes with broken color component 541 * lengths. 542 */ 543 if (mib->depth == 0 || (mib->depth == 24 && 544 mib->bits_per_pixel == 32)) 545 mib->depth = mib->bits_per_pixel; 546 } 547 548 if (par->vbe_modes_cnt > 0) 549 return 0; 550 else 551 return -EINVAL; 552} 553 554/* 555 * The Protected Mode Interface is 32-bit x86 code, so we only run it on 556 * x86 and not x86_64. 557 */ 558#ifdef CONFIG_X86_32 559static int __devinit uvesafb_vbe_getpmi(struct uvesafb_ktask *task, 560 struct uvesafb_par *par) 561{ 562 int i, err; 563 564 uvesafb_reset(task); 565 task->t.regs.eax = 0x4f0a; 566 task->t.regs.ebx = 0x0; 567 err = uvesafb_exec(task); 568 569 if ((task->t.regs.eax & 0xffff) != 0x4f || task->t.regs.es < 0xc000) { 570 par->pmi_setpal = par->ypan = 0; 571 } else { 572 par->pmi_base = (u16 *)phys_to_virt(((u32)task->t.regs.es << 4) 573 + task->t.regs.edi); 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 " 577 "%04x:%04x\n", 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, 581 par->pmi_pal); 582 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]); 588 printk("\n"); 589 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; 594 } 595 } 596 } 597 return 0; 598} 599#endif /* CONFIG_X86_32 */ 600 601/* 602 * Check whether a video mode is supported by the Video BIOS and is 603 * compatible with the monitor limits. 604 */ 605static int __devinit uvesafb_is_valid_mode(struct fb_videomode *mode, 606 struct fb_info *info) 607{ 608 if (info->monspecs.gtf) { 609 fb_videomode_to_var(&info->var, mode); 610 if (fb_validate_mode(&info->var, info)) 611 return 0; 612 } 613 614 if (uvesafb_vbe_find_mode(info->par, mode->xres, mode->yres, 8, 615 UVESAFB_EXACT_RES) == -1) 616 return 0; 617 618 return 1; 619} 620 621static int __devinit uvesafb_vbe_getedid(struct uvesafb_ktask *task, 622 struct fb_info *info) 623{ 624 struct uvesafb_par *par = info->par; 625 int err = 0; 626 627 if (noedid || par->vbe_ib.vbe_version < 0x0300) 628 return -EINVAL; 629 630 task->t.regs.eax = 0x4f15; 631 task->t.regs.ebx = 0; 632 task->t.regs.ecx = 0; 633 task->t.buf_len = 0; 634 task->t.flags = 0; 635 636 err = uvesafb_exec(task); 637 638 if ((task->t.regs.eax & 0xffff) != 0x004f || err) 639 return -EINVAL; 640 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 " 646 "transfers\n"); 647 } else if ((task->t.regs.ebx & 0x3) == 1) { 648 printk(KERN_INFO "uvesafb: VBIOS/hardware supports DDC1 " 649 "transfers\n"); 650 } else { 651 printk(KERN_INFO "uvesafb: VBIOS/hardware doesn't support " 652 "DDC transfers\n"); 653 return -EINVAL; 654 } 655 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); 662 663 err = uvesafb_exec(task); 664 665 if ((task->t.regs.eax & 0xffff) == 0x004f && !err) { 666 fb_edid_to_monspecs(task->buf, &info->monspecs); 667 668 if (info->monspecs.vfmax && info->monspecs.hfmax) { 669 /* 670 * If the maximum pixel clock wasn't specified in 671 * the EDID block, set it to 300 MHz. 672 */ 673 if (info->monspecs.dclkmax == 0) 674 info->monspecs.dclkmax = 300 * 1000000; 675 info->monspecs.gtf = 1; 676 } 677 } else { 678 err = -EINVAL; 679 } 680 681 kfree(task->buf); 682 return err; 683} 684 685static void __devinit uvesafb_vbe_getmonspecs(struct uvesafb_ktask *task, 686 struct fb_info *info) 687{ 688 struct uvesafb_par *par = info->par; 689 int i; 690 691 memset(&info->monspecs, 0, sizeof(info->monspecs)); 692 693 /* 694 * If we don't get all necessary data from the EDID block, 695 * mark it as incompatible with the GTF and set nocrtc so 696 * that we always use the default BIOS refresh rate. 697 */ 698 if (uvesafb_vbe_getedid(task, info)) { 699 info->monspecs.gtf = 0; 700 par->nocrtc = 1; 701 } 702 703 /* Kernel command line overrides. */ 704 if (maxclk) 705 info->monspecs.dclkmax = maxclk * 1000000; 706 if (maxvf) 707 info->monspecs.vfmax = maxvf; 708 if (maxhf) 709 info->monspecs.hfmax = maxhf * 1000; 710 711 /* 712 * In case DDC transfers are not supported, the user can provide 713 * monitor limits manually. Lower limits are set to "safe" values. 714 */ 715 if (info->monspecs.gtf == 0 && maxclk && maxvf && maxhf) { 716 info->monspecs.dclkmin = 0; 717 info->monspecs.vfmin = 60; 718 info->monspecs.hfmin = 29000; 719 info->monspecs.gtf = 1; 720 par->nocrtc = 0; 721 } 722 723 if (info->monspecs.gtf) 724 printk(KERN_INFO 725 "uvesafb: monitor limits: vf = %d Hz, hf = %d kHz, " 726 "clk = %d MHz\n", info->monspecs.vfmax, 727 (int)(info->monspecs.hfmax / 1000), 728 (int)(info->monspecs.dclkmax / 1000000)); 729 else 730 printk(KERN_INFO "uvesafb: no monitor limits have been set, " 731 "default refresh rate will be used\n"); 732 733 /* Add VBE modes to the modelist. */ 734 for (i = 0; i < par->vbe_modes_cnt; i++) { 735 struct fb_var_screeninfo var; 736 struct vbe_mode_ib *mode; 737 struct fb_videomode vmode; 738 739 mode = &par->vbe_modes[i]; 740 memset(&var, 0, sizeof(var)); 741 742 var.xres = mode->x_res; 743 var.yres = mode->y_res; 744 745 fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, 60, &var, info); 746 fb_var_to_videomode(&vmode, &var); 747 fb_add_videomode(&vmode, &info->modelist); 748 } 749 750 /* Add valid VESA modes to our modelist. */ 751 for (i = 0; i < VESA_MODEDB_SIZE; i++) { 752 if (uvesafb_is_valid_mode((struct fb_videomode *) 753 &vesa_modes[i], info)) 754 fb_add_videomode(&vesa_modes[i], &info->modelist); 755 } 756 757 for (i = 0; i < info->monspecs.modedb_len; i++) { 758 if (uvesafb_is_valid_mode(&info->monspecs.modedb[i], info)) 759 fb_add_videomode(&info->monspecs.modedb[i], 760 &info->modelist); 761 } 762 763 return; 764} 765 766static void __devinit uvesafb_vbe_getstatesize(struct uvesafb_ktask *task, 767 struct uvesafb_par *par) 768{ 769 int err; 770 771 uvesafb_reset(task); 772 773 /* 774 * Get the VBE state buffer size. We want all available 775 * hardware state data (CL = 0x0f). 776 */ 777 task->t.regs.eax = 0x4f04; 778 task->t.regs.ecx = 0x000f; 779 task->t.regs.edx = 0x0000; 780 task->t.flags = 0; 781 782 err = uvesafb_exec(task); 783 784 if (err || (task->t.regs.eax & 0xffff) != 0x004f) { 785 printk(KERN_WARNING "uvesafb: VBE state buffer size " 786 "cannot be determined (eax=0x%x, err=%d)\n", 787 task->t.regs.eax, err); 788 par->vbe_state_size = 0; 789 return; 790 } 791 792 par->vbe_state_size = 64 * (task->t.regs.ebx & 0xffff); 793} 794 795static int __devinit uvesafb_vbe_init(struct fb_info *info) 796{ 797 struct uvesafb_ktask *task = NULL; 798 struct uvesafb_par *par = info->par; 799 int err; 800 801 task = uvesafb_prep(); 802 if (!task) 803 return -ENOMEM; 804 805 err = uvesafb_vbe_getinfo(task, par); 806 if (err) 807 goto out; 808 809 err = uvesafb_vbe_getmodes(task, par); 810 if (err) 811 goto out; 812 813 par->nocrtc = nocrtc; 814#ifdef CONFIG_X86_32 815 par->pmi_setpal = pmi_setpal; 816 par->ypan = ypan; 817 818 if (par->pmi_setpal || par->ypan) 819 uvesafb_vbe_getpmi(task, par); 820#else 821 /* The protected mode interface is not available on non-x86. */ 822 par->pmi_setpal = par->ypan = 0; 823#endif 824 825 INIT_LIST_HEAD(&info->modelist); 826 uvesafb_vbe_getmonspecs(task, info); 827 uvesafb_vbe_getstatesize(task, par); 828 829out: uvesafb_free(task); 830 return err; 831} 832 833static int __devinit uvesafb_vbe_init_mode(struct fb_info *info) 834{ 835 struct list_head *pos; 836 struct fb_modelist *modelist; 837 struct fb_videomode *mode; 838 struct uvesafb_par *par = info->par; 839 int i, modeid; 840 841 /* Has the user requested a specific VESA mode? */ 842 if (vbemode) { 843 for (i = 0; i < par->vbe_modes_cnt; i++) { 844 if (par->vbe_modes[i].mode_id == vbemode) { 845 modeid = i; 846 uvesafb_setup_var(&info->var, info, 847 &par->vbe_modes[modeid]); 848 fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, 60, 849 &info->var, info); 850 /* 851 * With pixclock set to 0, the default BIOS 852 * timings will be used in set_par(). 853 */ 854 info->var.pixclock = 0; 855 goto gotmode; 856 } 857 } 858 printk(KERN_INFO "uvesafb: requested VBE mode 0x%x is " 859 "unavailable\n", vbemode); 860 vbemode = 0; 861 } 862 863 /* Count the modes in the modelist */ 864 i = 0; 865 list_for_each(pos, &info->modelist) 866 i++; 867 868 /* 869 * Convert the modelist into a modedb so that we can use it with 870 * fb_find_mode(). 871 */ 872 mode = kzalloc(i * sizeof(*mode), GFP_KERNEL); 873 if (mode) { 874 i = 0; 875 list_for_each(pos, &info->modelist) { 876 modelist = list_entry(pos, struct fb_modelist, list); 877 mode[i] = modelist->mode; 878 i++; 879 } 880 881 if (!mode_option) 882 mode_option = UVESAFB_DEFAULT_MODE; 883 884 i = fb_find_mode(&info->var, info, mode_option, mode, i, 885 NULL, 8); 886 887 kfree(mode); 888 } 889 890 /* fb_find_mode() failed */ 891 if (i == 0) { 892 info->var.xres = 640; 893 info->var.yres = 480; 894 mode = (struct fb_videomode *) 895 fb_find_best_mode(&info->var, &info->modelist); 896 897 if (mode) { 898 fb_videomode_to_var(&info->var, mode); 899 } else { 900 modeid = par->vbe_modes[0].mode_id; 901 uvesafb_setup_var(&info->var, info, 902 &par->vbe_modes[modeid]); 903 fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, 60, 904 &info->var, info); 905 906 goto gotmode; 907 } 908 } 909 910 /* Look for a matching VBE mode. */ 911 modeid = uvesafb_vbe_find_mode(par, info->var.xres, info->var.yres, 912 info->var.bits_per_pixel, UVESAFB_EXACT_RES); 913 914 if (modeid == -1) 915 return -EINVAL; 916 917 uvesafb_setup_var(&info->var, info, &par->vbe_modes[modeid]); 918 919gotmode: 920 /* 921 * If we are not VBE3.0+ compliant, we're done -- the BIOS will 922 * ignore our timings anyway. 923 */ 924 if (par->vbe_ib.vbe_version < 0x0300 || par->nocrtc) 925 fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, 60, 926 &info->var, info); 927 928 return modeid; 929} 930 931static int uvesafb_setpalette(struct uvesafb_pal_entry *entries, int count, 932 int start, struct fb_info *info) 933{ 934 struct uvesafb_ktask *task; 935#ifdef CONFIG_X86 936 struct uvesafb_par *par = info->par; 937 int i = par->mode_idx; 938#endif 939 int err = 0; 940 941 /* 942 * We support palette modifications for 8 bpp modes only, so 943 * there can never be more than 256 entries. 944 */ 945 if (start + count > 256) 946 return -EINVAL; 947 948#ifdef CONFIG_X86 949 /* Use VGA registers if mode is VGA-compatible. */ 950 if (i >= 0 && i < par->vbe_modes_cnt && 951 par->vbe_modes[i].mode_attr & VBE_MODE_VGACOMPAT) { 952 for (i = 0; i < count; i++) { 953 outb_p(start + i, dac_reg); 954 outb_p(entries[i].red, dac_val); 955 outb_p(entries[i].green, dac_val); 956 outb_p(entries[i].blue, dac_val); 957 } 958 } 959#ifdef CONFIG_X86_32 960 else if (par->pmi_setpal) { 961 __asm__ __volatile__( 962 "call *(%%esi)" 963 : /* no return value */ 964 : "a" (0x4f09), /* EAX */ 965 "b" (0), /* EBX */ 966 "c" (count), /* ECX */ 967 "d" (start), /* EDX */ 968 "D" (entries), /* EDI */ 969 "S" (&par->pmi_pal)); /* ESI */ 970 } 971#endif /* CONFIG_X86_32 */ 972 else 973#endif /* CONFIG_X86 */ 974 { 975 task = uvesafb_prep(); 976 if (!task) 977 return -ENOMEM; 978 979 task->t.regs.eax = 0x4f09; 980 task->t.regs.ebx = 0x0; 981 task->t.regs.ecx = count; 982 task->t.regs.edx = start; 983 task->t.flags = TF_BUF_ESDI; 984 task->t.buf_len = sizeof(struct uvesafb_pal_entry) * count; 985 task->buf = entries; 986 987 err = uvesafb_exec(task); 988 if ((task->t.regs.eax & 0xffff) != 0x004f) 989 err = 1; 990 991 uvesafb_free(task); 992 } 993 return err; 994} 995 996static int uvesafb_setcolreg(unsigned regno, unsigned red, unsigned green, 997 unsigned blue, unsigned transp, 998 struct fb_info *info) 999{ 1000 struct uvesafb_pal_entry entry; 1001 int shift = 16 - dac_width; 1002 int err = 0; 1003 1004 if (regno >= info->cmap.len) 1005 return -EINVAL; 1006 1007 if (info->var.bits_per_pixel == 8) { 1008 entry.red = red >> shift; 1009 entry.green = green >> shift; 1010 entry.blue = blue >> shift; 1011 entry.pad = 0; 1012 1013 err = uvesafb_setpalette(&entry, 1, regno, info); 1014 } else if (regno < 16) { 1015 switch (info->var.bits_per_pixel) { 1016 case 16: 1017 if (info->var.red.offset == 10) { 1018 /* 1:5:5:5 */ 1019 ((u32 *) (info->pseudo_palette))[regno] = 1020 ((red & 0xf800) >> 1) | 1021 ((green & 0xf800) >> 6) | 1022 ((blue & 0xf800) >> 11); 1023 } else { 1024 /* 0:5:6:5 */ 1025 ((u32 *) (info->pseudo_palette))[regno] = 1026 ((red & 0xf800) ) | 1027 ((green & 0xfc00) >> 5) | 1028 ((blue & 0xf800) >> 11); 1029 } 1030 break; 1031 1032 case 24: 1033 case 32: 1034 red >>= 8; 1035 green >>= 8; 1036 blue >>= 8; 1037 ((u32 *)(info->pseudo_palette))[regno] = 1038 (red << info->var.red.offset) | 1039 (green << info->var.green.offset) | 1040 (blue << info->var.blue.offset); 1041 break; 1042 } 1043 } 1044 return err; 1045} 1046 1047static int uvesafb_setcmap(struct fb_cmap *cmap, struct fb_info *info) 1048{ 1049 struct uvesafb_pal_entry *entries; 1050 int shift = 16 - dac_width; 1051 int i, err = 0; 1052 1053 if (info->var.bits_per_pixel == 8) { 1054 if (cmap->start + cmap->len > info->cmap.start + 1055 info->cmap.len || cmap->start < info->cmap.start) 1056 return -EINVAL; 1057 1058 entries = kmalloc(sizeof(*entries) * cmap->len, GFP_KERNEL); 1059 if (!entries) 1060 return -ENOMEM; 1061 1062 for (i = 0; i < cmap->len; i++) { 1063 entries[i].red = cmap->red[i] >> shift; 1064 entries[i].green = cmap->green[i] >> shift; 1065 entries[i].blue = cmap->blue[i] >> shift; 1066 entries[i].pad = 0; 1067 } 1068 err = uvesafb_setpalette(entries, cmap->len, cmap->start, info); 1069 kfree(entries); 1070 } else { 1071 /* 1072 * For modes with bpp > 8, we only set the pseudo palette in 1073 * the fb_info struct. We rely on uvesafb_setcolreg to do all 1074 * sanity checking. 1075 */ 1076 for (i = 0; i < cmap->len; i++) { 1077 err |= uvesafb_setcolreg(cmap->start + i, cmap->red[i], 1078 cmap->green[i], cmap->blue[i], 1079 0, info); 1080 } 1081 } 1082 return err; 1083} 1084 1085static int uvesafb_pan_display(struct fb_var_screeninfo *var, 1086 struct fb_info *info) 1087{ 1088#ifdef CONFIG_X86_32 1089 int offset; 1090 struct uvesafb_par *par = info->par; 1091 1092 offset = (var->yoffset * info->fix.line_length + var->xoffset) / 4; 1093 1094 /* 1095 * It turns out it's not the best idea to do panning via vm86, 1096 * so we only allow it if we have a PMI. 1097 */ 1098 if (par->pmi_start) { 1099 __asm__ __volatile__( 1100 "call *(%%edi)" 1101 : /* no return value */ 1102 : "a" (0x4f07), /* EAX */ 1103 "b" (0), /* EBX */ 1104 "c" (offset), /* ECX */ 1105 "d" (offset >> 16), /* EDX */ 1106 "D" (&par->pmi_start)); /* EDI */ 1107 } 1108#endif 1109 return 0; 1110} 1111 1112static int uvesafb_blank(int blank, struct fb_info *info) 1113{ 1114 struct uvesafb_ktask *task; 1115 int err = 1; 1116#ifdef CONFIG_X86 1117 struct uvesafb_par *par = info->par; 1118 1119 if (par->vbe_ib.capabilities & VBE_CAP_VGACOMPAT) { 1120 int loop = 10000; 1121 u8 seq = 0, crtc17 = 0; 1122 1123 if (blank == FB_BLANK_POWERDOWN) { 1124 seq = 0x20; 1125 crtc17 = 0x00; 1126 err = 0; 1127 } else { 1128 seq = 0x00; 1129 crtc17 = 0x80; 1130 err = (blank == FB_BLANK_UNBLANK) ? 0 : -EINVAL; 1131 } 1132 1133 vga_wseq(NULL, 0x00, 0x01); 1134 seq |= vga_rseq(NULL, 0x01) & ~0x20; 1135 vga_wseq(NULL, 0x00, seq); 1136 1137 crtc17 |= vga_rcrt(NULL, 0x17) & ~0x80; 1138 while (loop--); 1139 vga_wcrt(NULL, 0x17, crtc17); 1140 vga_wseq(NULL, 0x00, 0x03); 1141 } else 1142#endif /* CONFIG_X86 */ 1143 { 1144 task = uvesafb_prep(); 1145 if (!task) 1146 return -ENOMEM; 1147 1148 task->t.regs.eax = 0x4f10; 1149 switch (blank) { 1150 case FB_BLANK_UNBLANK: 1151 task->t.regs.ebx = 0x0001; 1152 break; 1153 case FB_BLANK_NORMAL: 1154 task->t.regs.ebx = 0x0101; /* standby */ 1155 break; 1156 case FB_BLANK_POWERDOWN: 1157 task->t.regs.ebx = 0x0401; /* powerdown */ 1158 break; 1159 default: 1160 goto out; 1161 } 1162 1163 err = uvesafb_exec(task); 1164 if (err || (task->t.regs.eax & 0xffff) != 0x004f) 1165 err = 1; 1166out: uvesafb_free(task); 1167 } 1168 return err; 1169} 1170 1171static int uvesafb_open(struct fb_info *info, int user) 1172{ 1173 struct uvesafb_par *par = info->par; 1174 int cnt = atomic_read(&par->ref_count); 1175 1176 if (!cnt && par->vbe_state_size) 1177 par->vbe_state_orig = uvesafb_vbe_state_save(par); 1178 1179 atomic_inc(&par->ref_count); 1180 return 0; 1181} 1182 1183static int uvesafb_release(struct fb_info *info, int user) 1184{ 1185 struct uvesafb_ktask *task = NULL; 1186 struct uvesafb_par *par = info->par; 1187 int cnt = atomic_read(&par->ref_count); 1188 1189 if (!cnt) 1190 return -EINVAL; 1191 1192 if (cnt != 1) 1193 goto out; 1194 1195 task = uvesafb_prep(); 1196 if (!task) 1197 goto out; 1198 1199 /* First, try to set the standard 80x25 text mode. */ 1200 task->t.regs.eax = 0x0003; 1201 uvesafb_exec(task); 1202 1203 /* 1204 * Now try to restore whatever hardware state we might have 1205 * saved when the fb device was first opened. 1206 */ 1207 uvesafb_vbe_state_restore(par, par->vbe_state_orig); 1208out: 1209 atomic_dec(&par->ref_count); 1210 if (task) 1211 uvesafb_free(task); 1212 return 0; 1213} 1214 1215static int uvesafb_set_par(struct fb_info *info) 1216{ 1217 struct uvesafb_par *par = info->par; 1218 struct uvesafb_ktask *task = NULL; 1219 struct vbe_crtc_ib *crtc = NULL; 1220 struct vbe_mode_ib *mode = NULL; 1221 int i, err = 0, depth = info->var.bits_per_pixel; 1222 1223 if (depth > 8 && depth != 32) 1224 depth = info->var.red.length + info->var.green.length + 1225 info->var.blue.length; 1226 1227 i = uvesafb_vbe_find_mode(par, info->var.xres, info->var.yres, depth, 1228 UVESAFB_EXACT_RES | UVESAFB_EXACT_DEPTH); 1229 if (i >= 0) 1230 mode = &par->vbe_modes[i]; 1231 else 1232 return -EINVAL; 1233 1234 task = uvesafb_prep(); 1235 if (!task) 1236 return -ENOMEM; 1237setmode: 1238 task->t.regs.eax = 0x4f02; 1239 task->t.regs.ebx = mode->mode_id | 0x4000; /* use LFB */ 1240 1241 if (par->vbe_ib.vbe_version >= 0x0300 && !par->nocrtc && 1242 info->var.pixclock != 0) { 1243 task->t.regs.ebx |= 0x0800; /* use CRTC data */ 1244 task->t.flags = TF_BUF_ESDI; 1245 crtc = kzalloc(sizeof(struct vbe_crtc_ib), GFP_KERNEL); 1246 if (!crtc) { 1247 err = -ENOMEM; 1248 goto out; 1249 } 1250 crtc->horiz_start = info->var.xres + info->var.right_margin; 1251 crtc->horiz_end = crtc->horiz_start + info->var.hsync_len; 1252 crtc->horiz_total = crtc->horiz_end + info->var.left_margin; 1253 1254 crtc->vert_start = info->var.yres + info->var.lower_margin; 1255 crtc->vert_end = crtc->vert_start + info->var.vsync_len; 1256 crtc->vert_total = crtc->vert_end + info->var.upper_margin; 1257 1258 crtc->pixel_clock = PICOS2KHZ(info->var.pixclock) * 1000; 1259 crtc->refresh_rate = (u16)(100 * (crtc->pixel_clock / 1260 (crtc->vert_total * crtc->horiz_total))); 1261 1262 if (info->var.vmode & FB_VMODE_DOUBLE) 1263 crtc->flags |= 0x1; 1264 if (info->var.vmode & FB_VMODE_INTERLACED) 1265 crtc->flags |= 0x2; 1266 if (!(info->var.sync & FB_SYNC_HOR_HIGH_ACT)) 1267 crtc->flags |= 0x4; 1268 if (!(info->var.sync & FB_SYNC_VERT_HIGH_ACT)) 1269 crtc->flags |= 0x8; 1270 memcpy(&par->crtc, crtc, sizeof(*crtc)); 1271 } else { 1272 memset(&par->crtc, 0, sizeof(*crtc)); 1273 } 1274 1275 task->t.buf_len = sizeof(struct vbe_crtc_ib); 1276 task->buf = &par->crtc; 1277 1278 err = uvesafb_exec(task); 1279 if (err || (task->t.regs.eax & 0xffff) != 0x004f) { 1280 /* 1281 * The mode switch might have failed because we tried to 1282 * use our own timings. Try again with the default timings. 1283 */ 1284 if (crtc != NULL) { 1285 printk(KERN_WARNING "uvesafb: mode switch failed " 1286 "(eax=0x%x, err=%d). Trying again with " 1287 "default timings.\n", task->t.regs.eax, err); 1288 uvesafb_reset(task); 1289 kfree(crtc); 1290 crtc = NULL; 1291 info->var.pixclock = 0; 1292 goto setmode; 1293 } else { 1294 printk(KERN_ERR "uvesafb: mode switch failed (eax=" 1295 "0x%x, err=%d)\n", task->t.regs.eax, err); 1296 err = -EINVAL; 1297 goto out; 1298 } 1299 } 1300 par->mode_idx = i; 1301 1302 /* For 8bpp modes, always try to set the DAC to 8 bits. */ 1303 if (par->vbe_ib.capabilities & VBE_CAP_CAN_SWITCH_DAC && 1304 mode->bits_per_pixel <= 8) { 1305 uvesafb_reset(task); 1306 task->t.regs.eax = 0x4f08; 1307 task->t.regs.ebx = 0x0800; 1308 1309 err = uvesafb_exec(task); 1310 if (err || (task->t.regs.eax & 0xffff) != 0x004f || 1311 ((task->t.regs.ebx & 0xff00) >> 8) != 8) { 1312 dac_width = 6; 1313 } else { 1314 dac_width = 8; 1315 } 1316 } 1317 1318 info->fix.visual = (info->var.bits_per_pixel == 8) ? 1319 FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR; 1320 info->fix.line_length = mode->bytes_per_scan_line; 1321 1322out: if (crtc != NULL) 1323 kfree(crtc); 1324 uvesafb_free(task); 1325 1326 return err; 1327} 1328 1329static void uvesafb_check_limits(struct fb_var_screeninfo *var, 1330 struct fb_info *info) 1331{ 1332 const struct fb_videomode *mode; 1333 struct uvesafb_par *par = info->par; 1334 1335 /* 1336 * If pixclock is set to 0, then we're using default BIOS timings 1337 * and thus don't have to perform any checks here. 1338 */ 1339 if (!var->pixclock) 1340 return; 1341 1342 if (par->vbe_ib.vbe_version < 0x0300) { 1343 fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, 60, var, info); 1344 return; 1345 } 1346 1347 if (!fb_validate_mode(var, info)) 1348 return; 1349 1350 mode = fb_find_best_mode(var, &info->modelist); 1351 if (mode) { 1352 if (mode->xres == var->xres && mode->yres == var->yres && 1353 !(mode->vmode & (FB_VMODE_INTERLACED | FB_VMODE_DOUBLE))) { 1354 fb_videomode_to_var(var, mode); 1355 return; 1356 } 1357 } 1358 1359 if (info->monspecs.gtf && !fb_get_mode(FB_MAXTIMINGS, 0, var, info)) 1360 return; 1361 /* Use default refresh rate */ 1362 var->pixclock = 0; 1363} 1364 1365static int uvesafb_check_var(struct fb_var_screeninfo *var, 1366 struct fb_info *info) 1367{ 1368 struct uvesafb_par *par = info->par; 1369 struct vbe_mode_ib *mode = NULL; 1370 int match = -1; 1371 int depth = var->red.length + var->green.length + var->blue.length; 1372 1373 /* 1374 * Various apps will use bits_per_pixel to set the color depth, 1375 * which is theoretically incorrect, but which we'll try to handle 1376 * here. 1377 */ 1378 if (depth == 0 || abs(depth - var->bits_per_pixel) >= 8) 1379 depth = var->bits_per_pixel; 1380 1381 match = uvesafb_vbe_find_mode(par, var->xres, var->yres, depth, 1382 UVESAFB_EXACT_RES); 1383 if (match == -1) 1384 return -EINVAL; 1385 1386 mode = &par->vbe_modes[match]; 1387 uvesafb_setup_var(var, info, mode); 1388 1389 /* 1390 * Check whether we have remapped enough memory for this mode. 1391 * We might be called at an early stage, when we haven't remapped 1392 * any memory yet, in which case we simply skip the check. 1393 */ 1394 if (var->yres * mode->bytes_per_scan_line > info->fix.smem_len 1395 && info->fix.smem_len) 1396 return -EINVAL; 1397 1398 if ((var->vmode & FB_VMODE_DOUBLE) && 1399 !(par->vbe_modes[match].mode_attr & 0x100)) 1400 var->vmode &= ~FB_VMODE_DOUBLE; 1401 1402 if ((var->vmode & FB_VMODE_INTERLACED) && 1403 !(par->vbe_modes[match].mode_attr & 0x200)) 1404 var->vmode &= ~FB_VMODE_INTERLACED; 1405 1406 uvesafb_check_limits(var, info); 1407 1408 var->xres_virtual = var->xres; 1409 var->yres_virtual = (par->ypan) ? 1410 info->fix.smem_len / mode->bytes_per_scan_line : 1411 var->yres; 1412 return 0; 1413} 1414 1415static struct fb_ops uvesafb_ops = { 1416 .owner = THIS_MODULE, 1417 .fb_open = uvesafb_open, 1418 .fb_release = uvesafb_release, 1419 .fb_setcolreg = uvesafb_setcolreg, 1420 .fb_setcmap = uvesafb_setcmap, 1421 .fb_pan_display = uvesafb_pan_display, 1422 .fb_blank = uvesafb_blank, 1423 .fb_fillrect = cfb_fillrect, 1424 .fb_copyarea = cfb_copyarea, 1425 .fb_imageblit = cfb_imageblit, 1426 .fb_check_var = uvesafb_check_var, 1427 .fb_set_par = uvesafb_set_par, 1428}; 1429 1430static void __devinit uvesafb_init_info(struct fb_info *info, 1431 struct vbe_mode_ib *mode) 1432{ 1433 unsigned int size_vmode; 1434 unsigned int size_remap; 1435 unsigned int size_total; 1436 struct uvesafb_par *par = info->par; 1437 int i, h; 1438 1439 info->pseudo_palette = ((u8 *)info->par + sizeof(struct uvesafb_par)); 1440 info->fix = uvesafb_fix; 1441 info->fix.ypanstep = par->ypan ? 1 : 0; 1442 info->fix.ywrapstep = (par->ypan > 1) ? 1 : 0; 1443 1444 /* Disable blanking if the user requested so. */ 1445 if (!blank) 1446 info->fbops->fb_blank = NULL; 1447 1448 /* 1449 * Find out how much IO memory is required for the mode with 1450 * the highest resolution. 1451 */ 1452 size_remap = 0; 1453 for (i = 0; i < par->vbe_modes_cnt; i++) { 1454 h = par->vbe_modes[i].bytes_per_scan_line * 1455 par->vbe_modes[i].y_res; 1456 if (h > size_remap) 1457 size_remap = h; 1458 } 1459 size_remap *= 2; 1460 1461 /* 1462 * size_vmode -- that is the amount of memory needed for the 1463 * used video mode, i.e. the minimum amount of 1464 * memory we need. 1465 */ 1466 if (mode != NULL) { 1467 size_vmode = info->var.yres * mode->bytes_per_scan_line; 1468 } else { 1469 size_vmode = info->var.yres * info->var.xres * 1470 ((info->var.bits_per_pixel + 7) >> 3); 1471 } 1472 1473 /* 1474 * size_total -- all video memory we have. Used for mtrr 1475 * entries, resource allocation and bounds 1476 * checking. 1477 */ 1478 size_total = par->vbe_ib.total_memory * 65536; 1479 if (vram_total) 1480 size_total = vram_total * 1024 * 1024; 1481 if (size_total < size_vmode) 1482 size_total = size_vmode; 1483 1484 /* 1485 * size_remap -- the amount of video memory we are going to 1486 * use for vesafb. With modern cards it is no 1487 * option to simply use size_total as th 1488 * wastes plenty of kernel address space. 1489 */ 1490 if (vram_remap) 1491 size_remap = vram_remap * 1024 * 1024; 1492 if (size_remap < size_vmode) 1493 size_remap = size_vmode; 1494 if (size_remap > size_total) 1495 size_remap = size_total; 1496 1497 info->fix.smem_len = size_remap; 1498 info->fix.smem_start = mode->phys_base_ptr; 1499 1500 /* 1501 * We have to set yres_virtual here because when setup_var() was 1502 * called, smem_len wasn't defined yet. 1503 */ 1504 info->var.yres_virtual = info->fix.smem_len / 1505 mode->bytes_per_scan_line; 1506 1507 if (par->ypan && info->var.yres_virtual > info->var.yres) { 1508 printk(KERN_INFO "uvesafb: scrolling: %s " 1509 "using protected mode interface, " 1510 "yres_virtual=%d\n", 1511 (par->ypan > 1) ? "ywrap" : "ypan", 1512 info->var.yres_virtual); 1513 } else { 1514 printk(KERN_INFO "uvesafb: scrolling: redraw\n"); 1515 info->var.yres_virtual = info->var.yres; 1516 par->ypan = 0; 1517 } 1518 1519 info->flags = FBINFO_FLAG_DEFAULT | 1520 (par->ypan ? FBINFO_HWACCEL_YPAN : 0); 1521 1522 if (!par->ypan) 1523 info->fbops->fb_pan_display = NULL; 1524} 1525 1526static void __devinit uvesafb_init_mtrr(struct fb_info *info) 1527{ 1528#ifdef CONFIG_MTRR 1529 if (mtrr && !(info->fix.smem_start & (PAGE_SIZE - 1))) { 1530 int temp_size = info->fix.smem_len; 1531 unsigned int type = 0; 1532 1533 switch (mtrr) { 1534 case 1: 1535 type = MTRR_TYPE_UNCACHABLE; 1536 break; 1537 case 2: 1538 type = MTRR_TYPE_WRBACK; 1539 break; 1540 case 3: 1541 type = MTRR_TYPE_WRCOMB; 1542 break; 1543 case 4: 1544 type = MTRR_TYPE_WRTHROUGH; 1545 break; 1546 default: 1547 type = 0; 1548 break; 1549 } 1550 1551 if (type) { 1552 int rc; 1553 1554 /* Find the largest power-of-two */ 1555 while (temp_size & (temp_size - 1)) 1556 temp_size &= (temp_size - 1); 1557 1558 /* Try and find a power of two to add */ 1559 do { 1560 rc = mtrr_add(info->fix.smem_start, 1561 temp_size, type, 1); 1562 temp_size >>= 1; 1563 } while (temp_size >= PAGE_SIZE && rc == -EINVAL); 1564 } 1565 } 1566#endif /* CONFIG_MTRR */ 1567} 1568 1569 1570static ssize_t uvesafb_show_vbe_ver(struct device *dev, 1571 struct device_attribute *attr, char *buf) 1572{ 1573 struct fb_info *info = platform_get_drvdata(to_platform_device(dev)); 1574 struct uvesafb_par *par = info->par; 1575 1576 return snprintf(buf, PAGE_SIZE, "%.4x\n", par->vbe_ib.vbe_version); 1577} 1578 1579static DEVICE_ATTR(vbe_version, S_IRUGO, uvesafb_show_vbe_ver, NULL); 1580 1581static ssize_t uvesafb_show_vbe_modes(struct device *dev, 1582 struct device_attribute *attr, char *buf) 1583{ 1584 struct fb_info *info = platform_get_drvdata(to_platform_device(dev)); 1585 struct uvesafb_par *par = info->par; 1586 int ret = 0, i; 1587 1588 for (i = 0; i < par->vbe_modes_cnt && ret < PAGE_SIZE; i++) { 1589 ret += snprintf(buf + ret, PAGE_SIZE - ret, 1590 "%dx%d-%d, 0x%.4x\n", 1591 par->vbe_modes[i].x_res, par->vbe_modes[i].y_res, 1592 par->vbe_modes[i].depth, par->vbe_modes[i].mode_id); 1593 } 1594 1595 return ret; 1596} 1597 1598static DEVICE_ATTR(vbe_modes, S_IRUGO, uvesafb_show_vbe_modes, NULL); 1599 1600static ssize_t uvesafb_show_vendor(struct device *dev, 1601 struct device_attribute *attr, char *buf) 1602{ 1603 struct fb_info *info = platform_get_drvdata(to_platform_device(dev)); 1604 struct uvesafb_par *par = info->par; 1605 1606 if (par->vbe_ib.oem_vendor_name_ptr) 1607 return snprintf(buf, PAGE_SIZE, "%s\n", (char *) 1608 (&par->vbe_ib) + par->vbe_ib.oem_vendor_name_ptr); 1609 else 1610 return 0; 1611} 1612 1613static DEVICE_ATTR(oem_vendor, S_IRUGO, uvesafb_show_vendor, NULL); 1614 1615static ssize_t uvesafb_show_product_name(struct device *dev, 1616 struct device_attribute *attr, char *buf) 1617{ 1618 struct fb_info *info = platform_get_drvdata(to_platform_device(dev)); 1619 struct uvesafb_par *par = info->par; 1620 1621 if (par->vbe_ib.oem_product_name_ptr) 1622 return snprintf(buf, PAGE_SIZE, "%s\n", (char *) 1623 (&par->vbe_ib) + par->vbe_ib.oem_product_name_ptr); 1624 else 1625 return 0; 1626} 1627 1628static DEVICE_ATTR(oem_product_name, S_IRUGO, uvesafb_show_product_name, NULL); 1629 1630static ssize_t uvesafb_show_product_rev(struct device *dev, 1631 struct device_attribute *attr, char *buf) 1632{ 1633 struct fb_info *info = platform_get_drvdata(to_platform_device(dev)); 1634 struct uvesafb_par *par = info->par; 1635 1636 if (par->vbe_ib.oem_product_rev_ptr) 1637 return snprintf(buf, PAGE_SIZE, "%s\n", (char *) 1638 (&par->vbe_ib) + par->vbe_ib.oem_product_rev_ptr); 1639 else 1640 return 0; 1641} 1642 1643static DEVICE_ATTR(oem_product_rev, S_IRUGO, uvesafb_show_product_rev, NULL); 1644 1645static ssize_t uvesafb_show_oem_string(struct device *dev, 1646 struct device_attribute *attr, char *buf) 1647{ 1648 struct fb_info *info = platform_get_drvdata(to_platform_device(dev)); 1649 struct uvesafb_par *par = info->par; 1650 1651 if (par->vbe_ib.oem_string_ptr) 1652 return snprintf(buf, PAGE_SIZE, "%s\n", 1653 (char *)(&par->vbe_ib) + par->vbe_ib.oem_string_ptr); 1654 else 1655 return 0; 1656} 1657 1658static DEVICE_ATTR(oem_string, S_IRUGO, uvesafb_show_oem_string, NULL); 1659 1660static ssize_t uvesafb_show_nocrtc(struct device *dev, 1661 struct device_attribute *attr, char *buf) 1662{ 1663 struct fb_info *info = platform_get_drvdata(to_platform_device(dev)); 1664 struct uvesafb_par *par = info->par; 1665 1666 return snprintf(buf, PAGE_SIZE, "%d\n", par->nocrtc); 1667} 1668 1669static ssize_t uvesafb_store_nocrtc(struct device *dev, 1670 struct device_attribute *attr, const char *buf, size_t count) 1671{ 1672 struct fb_info *info = platform_get_drvdata(to_platform_device(dev)); 1673 struct uvesafb_par *par = info->par; 1674 1675 if (count > 0) { 1676 if (buf[0] == '0') 1677 par->nocrtc = 0; 1678 else 1679 par->nocrtc = 1; 1680 } 1681 return count; 1682} 1683 1684static DEVICE_ATTR(nocrtc, S_IRUGO | S_IWUSR, uvesafb_show_nocrtc, 1685 uvesafb_store_nocrtc); 1686 1687static struct attribute *uvesafb_dev_attrs[] = { 1688 &dev_attr_vbe_version.attr, 1689 &dev_attr_vbe_modes.attr, 1690 &dev_attr_oem_vendor.attr, 1691 &dev_attr_oem_product_name.attr, 1692 &dev_attr_oem_product_rev.attr, 1693 &dev_attr_oem_string.attr, 1694 &dev_attr_nocrtc.attr, 1695 NULL, 1696}; 1697 1698static struct attribute_group uvesafb_dev_attgrp = { 1699 .name = NULL, 1700 .attrs = uvesafb_dev_attrs, 1701}; 1702 1703static int __devinit uvesafb_probe(struct platform_device *dev) 1704{ 1705 struct fb_info *info; 1706 struct vbe_mode_ib *mode = NULL; 1707 struct uvesafb_par *par; 1708 int err = 0, i; 1709 1710 info = framebuffer_alloc(sizeof(*par) + sizeof(u32) * 256, &dev->dev); 1711 if (!info) 1712 return -ENOMEM; 1713 1714 par = info->par; 1715 1716 err = uvesafb_vbe_init(info); 1717 if (err) { 1718 printk(KERN_ERR "uvesafb: vbe_init() failed with %d\n", err); 1719 goto out; 1720 } 1721 1722 info->fbops = &uvesafb_ops; 1723 1724 i = uvesafb_vbe_init_mode(info); 1725 if (i < 0) { 1726 err = -EINVAL; 1727 goto out; 1728 } else { 1729 mode = &par->vbe_modes[i]; 1730 } 1731 1732 if (fb_alloc_cmap(&info->cmap, 256, 0) < 0) { 1733 err = -ENXIO; 1734 goto out; 1735 } 1736 1737 uvesafb_init_info(info, mode); 1738 1739 if (!request_mem_region(info->fix.smem_start, info->fix.smem_len, 1740 "uvesafb")) { 1741 printk(KERN_ERR "uvesafb: cannot reserve video memory at " 1742 "0x%lx\n", info->fix.smem_start); 1743 err = -EIO; 1744 goto out_mode; 1745 } 1746 1747 info->screen_base = ioremap(info->fix.smem_start, info->fix.smem_len); 1748 1749 if (!info->screen_base) { 1750 printk(KERN_ERR 1751 "uvesafb: abort, cannot ioremap 0x%x bytes of video " 1752 "memory at 0x%lx\n", 1753 info->fix.smem_len, info->fix.smem_start); 1754 err = -EIO; 1755 goto out_mem; 1756 } 1757 1758 if (!request_region(0x3c0, 32, "uvesafb")) { 1759 printk(KERN_ERR "uvesafb: request region 0x3c0-0x3e0 failed\n"); 1760 err = -EIO; 1761 goto out_unmap; 1762 } 1763 1764 uvesafb_init_mtrr(info); 1765 platform_set_drvdata(dev, info); 1766 1767 if (register_framebuffer(info) < 0) { 1768 printk(KERN_ERR 1769 "uvesafb: failed to register framebuffer device\n"); 1770 err = -EINVAL; 1771 goto out_reg; 1772 } 1773 1774 printk(KERN_INFO "uvesafb: framebuffer at 0x%lx, mapped to 0x%p, " 1775 "using %dk, total %dk\n", info->fix.smem_start, 1776 info->screen_base, info->fix.smem_len/1024, 1777 par->vbe_ib.total_memory * 64); 1778 printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node, 1779 info->fix.id); 1780 1781 err = sysfs_create_group(&dev->dev.kobj, &uvesafb_dev_attgrp); 1782 if (err != 0) 1783 printk(KERN_WARNING "fb%d: failed to register attributes\n", 1784 info->node); 1785 1786 return 0; 1787 1788out_reg: 1789 release_region(0x3c0, 32); 1790out_unmap: 1791 iounmap(info->screen_base); 1792out_mem: 1793 release_mem_region(info->fix.smem_start, info->fix.smem_len); 1794out_mode: 1795 if (!list_empty(&info->modelist)) 1796 fb_destroy_modelist(&info->modelist); 1797 fb_destroy_modedb(info->monspecs.modedb); 1798 fb_dealloc_cmap(&info->cmap); 1799out: 1800 if (par->vbe_modes) 1801 kfree(par->vbe_modes); 1802 1803 framebuffer_release(info); 1804 return err; 1805} 1806 1807static int uvesafb_remove(struct platform_device *dev) 1808{ 1809 struct fb_info *info = platform_get_drvdata(dev); 1810 1811 if (info) { 1812 struct uvesafb_par *par = info->par; 1813 1814 sysfs_remove_group(&dev->dev.kobj, &uvesafb_dev_attgrp); 1815 unregister_framebuffer(info); 1816 release_region(0x3c0, 32); 1817 iounmap(info->screen_base); 1818 release_mem_region(info->fix.smem_start, info->fix.smem_len); 1819 fb_destroy_modedb(info->monspecs.modedb); 1820 fb_dealloc_cmap(&info->cmap); 1821 1822 if (par) { 1823 if (par->vbe_modes) 1824 kfree(par->vbe_modes); 1825 if (par->vbe_state_orig) 1826 kfree(par->vbe_state_orig); 1827 if (par->vbe_state_saved) 1828 kfree(par->vbe_state_saved); 1829 } 1830 1831 framebuffer_release(info); 1832 } 1833 return 0; 1834} 1835 1836static struct platform_driver uvesafb_driver = { 1837 .probe = uvesafb_probe, 1838 .remove = uvesafb_remove, 1839 .driver = { 1840 .name = "uvesafb", 1841 }, 1842}; 1843 1844static struct platform_device *uvesafb_device; 1845 1846#ifndef MODULE 1847static int __devinit uvesafb_setup(char *options) 1848{ 1849 char *this_opt; 1850 1851 if (!options || !*options) 1852 return 0; 1853 1854 while ((this_opt = strsep(&options, ",")) != NULL) { 1855 if (!*this_opt) continue; 1856 1857 if (!strcmp(this_opt, "redraw")) 1858 ypan = 0; 1859 else if (!strcmp(this_opt, "ypan")) 1860 ypan = 1; 1861 else if (!strcmp(this_opt, "ywrap")) 1862 ypan = 2; 1863 else if (!strcmp(this_opt, "vgapal")) 1864 pmi_setpal = 0; 1865 else if (!strcmp(this_opt, "pmipal")) 1866 pmi_setpal = 1; 1867 else if (!strncmp(this_opt, "mtrr:", 5)) 1868 mtrr = simple_strtoul(this_opt+5, NULL, 0); 1869 else if (!strcmp(this_opt, "nomtrr")) 1870 mtrr = 0; 1871 else if (!strcmp(this_opt, "nocrtc")) 1872 nocrtc = 1; 1873 else if (!strcmp(this_opt, "noedid")) 1874 noedid = 1; 1875 else if (!strcmp(this_opt, "noblank")) 1876 blank = 0; 1877 else if (!strncmp(this_opt, "vtotal:", 7)) 1878 vram_total = simple_strtoul(this_opt + 7, NULL, 0); 1879 else if (!strncmp(this_opt, "vremap:", 7)) 1880 vram_remap = simple_strtoul(this_opt + 7, NULL, 0); 1881 else if (!strncmp(this_opt, "maxhf:", 6)) 1882 maxhf = simple_strtoul(this_opt + 6, NULL, 0); 1883 else if (!strncmp(this_opt, "maxvf:", 6)) 1884 maxvf = simple_strtoul(this_opt + 6, NULL, 0); 1885 else if (!strncmp(this_opt, "maxclk:", 7)) 1886 maxclk = simple_strtoul(this_opt + 7, NULL, 0); 1887 else if (!strncmp(this_opt, "vbemode:", 8)) 1888 vbemode = simple_strtoul(this_opt + 8, NULL, 0); 1889 else if (this_opt[0] >= '0' && this_opt[0] <= '9') { 1890 mode_option = this_opt; 1891 } else { 1892 printk(KERN_WARNING 1893 "uvesafb: unrecognized option %s\n", this_opt); 1894 } 1895 } 1896 1897 return 0; 1898} 1899#endif /* !MODULE */ 1900 1901static ssize_t show_v86d(struct device_driver *dev, char *buf) 1902{ 1903 return snprintf(buf, PAGE_SIZE, "%s\n", v86d_path); 1904} 1905 1906static ssize_t store_v86d(struct device_driver *dev, const char *buf, 1907 size_t count) 1908{ 1909 strncpy(v86d_path, buf, PATH_MAX); 1910 return count; 1911} 1912 1913static DRIVER_ATTR(v86d, S_IRUGO | S_IWUSR, show_v86d, store_v86d); 1914 1915static int __devinit uvesafb_init(void) 1916{ 1917 int err; 1918 1919#ifndef MODULE 1920 char *option = NULL; 1921 1922 if (fb_get_options("uvesafb", &option)) 1923 return -ENODEV; 1924 uvesafb_setup(option); 1925#endif 1926 err = cn_add_callback(&uvesafb_cn_id, "uvesafb", uvesafb_cn_callback); 1927 if (err) 1928 return err; 1929 1930 err = platform_driver_register(&uvesafb_driver); 1931 1932 if (!err) { 1933 uvesafb_device = platform_device_alloc("uvesafb", 0); 1934 if (uvesafb_device) 1935 err = platform_device_add(uvesafb_device); 1936 else 1937 err = -ENOMEM; 1938 1939 if (err) { 1940 platform_device_put(uvesafb_device); 1941 platform_driver_unregister(&uvesafb_driver); 1942 cn_del_callback(&uvesafb_cn_id); 1943 return err; 1944 } 1945 1946 err = driver_create_file(&uvesafb_driver.driver, 1947 &driver_attr_v86d); 1948 if (err) { 1949 printk(KERN_WARNING "uvesafb: failed to register " 1950 "attributes\n"); 1951 err = 0; 1952 } 1953 } 1954 return err; 1955} 1956 1957module_init(uvesafb_init); 1958 1959static void __devexit uvesafb_exit(void) 1960{ 1961 struct uvesafb_ktask *task; 1962 1963 if (v86d_started) { 1964 task = uvesafb_prep(); 1965 if (task) { 1966 task->t.flags = TF_EXIT; 1967 uvesafb_exec(task); 1968 uvesafb_free(task); 1969 } 1970 } 1971 1972 cn_del_callback(&uvesafb_cn_id); 1973 driver_remove_file(&uvesafb_driver.driver, &driver_attr_v86d); 1974 platform_device_unregister(uvesafb_device); 1975 platform_driver_unregister(&uvesafb_driver); 1976} 1977 1978module_exit(uvesafb_exit); 1979 1980static int param_set_scroll(const char *val, const struct kernel_param *kp) 1981{ 1982 ypan = 0; 1983 1984 if (!strcmp(val, "redraw")) 1985 ypan = 0; 1986 else if (!strcmp(val, "ypan")) 1987 ypan = 1; 1988 else if (!strcmp(val, "ywrap")) 1989 ypan = 2; 1990 else 1991 return -EINVAL; 1992 1993 return 0; 1994} 1995static struct kernel_param_ops param_ops_scroll = { 1996 .set = param_set_scroll, 1997}; 1998#define param_check_scroll(name, p) __param_check(name, p, void) 1999 2000module_param_named(scroll, ypan, scroll, 0); 2001MODULE_PARM_DESC(scroll, 2002 "Scrolling mode, set to 'redraw', 'ypan', or 'ywrap'"); 2003module_param_named(vgapal, pmi_setpal, invbool, 0); 2004MODULE_PARM_DESC(vgapal, "Set palette using VGA registers"); 2005module_param_named(pmipal, pmi_setpal, bool, 0); 2006MODULE_PARM_DESC(pmipal, "Set palette using PMI calls"); 2007module_param(mtrr, uint, 0); 2008MODULE_PARM_DESC(mtrr, 2009 "Memory Type Range Registers setting. Use 0 to disable."); 2010module_param(blank, bool, 0); 2011MODULE_PARM_DESC(blank, "Enable hardware blanking"); 2012module_param(nocrtc, bool, 0); 2013MODULE_PARM_DESC(nocrtc, "Ignore CRTC timings when setting modes"); 2014module_param(noedid, bool, 0); 2015MODULE_PARM_DESC(noedid, 2016 "Ignore EDID-provided monitor limits when setting modes"); 2017module_param(vram_remap, uint, 0); 2018MODULE_PARM_DESC(vram_remap, "Set amount of video memory to be used [MiB]"); 2019module_param(vram_total, uint, 0); 2020MODULE_PARM_DESC(vram_total, "Set total amount of video memoery [MiB]"); 2021module_param(maxclk, ushort, 0); 2022MODULE_PARM_DESC(maxclk, "Maximum pixelclock [MHz], overrides EDID data"); 2023module_param(maxhf, ushort, 0); 2024MODULE_PARM_DESC(maxhf, 2025 "Maximum horizontal frequency [kHz], overrides EDID data"); 2026module_param(maxvf, ushort, 0); 2027MODULE_PARM_DESC(maxvf, 2028 "Maximum vertical frequency [Hz], overrides EDID data"); 2029module_param(mode_option, charp, 0); 2030MODULE_PARM_DESC(mode_option, 2031 "Specify initial video mode as \"<xres>x<yres>[-<bpp>][@<refresh>]\""); 2032module_param(vbemode, ushort, 0); 2033MODULE_PARM_DESC(vbemode, 2034 "VBE mode number to set, overrides the 'mode' option"); 2035module_param_string(v86d, v86d_path, PATH_MAX, 0660); 2036MODULE_PARM_DESC(v86d, "Path to the v86d userspace helper."); 2037 2038MODULE_LICENSE("GPL"); 2039MODULE_AUTHOR("Michal Januszewski <spock@gentoo.org>"); 2040MODULE_DESCRIPTION("Framebuffer driver for VBE2.0+ compliant graphics boards"); 2041