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