1/* 2 * linux/drivers/video/fbmem.c 3 * 4 * Copyright (C) 1994 Martin Schaller 5 * 6 * 2001 - Documented with DocBook 7 * - Brad Douglas <brad@neruo.com> 8 * 9 * This file is subject to the terms and conditions of the GNU General Public 10 * License. See the file COPYING in the main directory of this archive 11 * for more details. 12 */ 13 14#include <linux/module.h> 15 16#include <linux/compat.h> 17#include <linux/types.h> 18#include <linux/errno.h> 19#include <linux/kernel.h> 20#include <linux/major.h> 21#include <linux/slab.h> 22#include <linux/mm.h> 23#include <linux/mman.h> 24#include <linux/vt.h> 25#include <linux/init.h> 26#include <linux/linux_logo.h> 27#include <linux/proc_fs.h> 28#include <linux/seq_file.h> 29#include <linux/console.h> 30#include <linux/kmod.h> 31#include <linux/err.h> 32#include <linux/device.h> 33#include <linux/efi.h> 34#include <linux/fb.h> 35 36#include <asm/fb.h> 37 38 39 /* 40 * Frame buffer device initialization and setup routines 41 */ 42 43#define FBPIXMAPSIZE (1024 * 8) 44 45struct fb_info *registered_fb[FB_MAX] __read_mostly; 46int num_registered_fb __read_mostly; 47 48int lock_fb_info(struct fb_info *info) 49{ 50 mutex_lock(&info->lock); 51 if (!info->fbops) { 52 mutex_unlock(&info->lock); 53 return 0; 54 } 55 return 1; 56} 57EXPORT_SYMBOL(lock_fb_info); 58 59/* 60 * Helpers 61 */ 62 63int fb_get_color_depth(struct fb_var_screeninfo *var, 64 struct fb_fix_screeninfo *fix) 65{ 66 int depth = 0; 67 68 if (fix->visual == FB_VISUAL_MONO01 || 69 fix->visual == FB_VISUAL_MONO10) 70 depth = 1; 71 else { 72 if (var->green.length == var->blue.length && 73 var->green.length == var->red.length && 74 var->green.offset == var->blue.offset && 75 var->green.offset == var->red.offset) 76 depth = var->green.length; 77 else 78 depth = var->green.length + var->red.length + 79 var->blue.length; 80 } 81 82 return depth; 83} 84EXPORT_SYMBOL(fb_get_color_depth); 85 86/* 87 * Data padding functions. 88 */ 89void fb_pad_aligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 s_pitch, u32 height) 90{ 91 __fb_pad_aligned_buffer(dst, d_pitch, src, s_pitch, height); 92} 93EXPORT_SYMBOL(fb_pad_aligned_buffer); 94 95void fb_pad_unaligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 idx, u32 height, 96 u32 shift_high, u32 shift_low, u32 mod) 97{ 98 u8 mask = (u8) (0xfff << shift_high), tmp; 99 int i, j; 100 101 for (i = height; i--; ) { 102 for (j = 0; j < idx; j++) { 103 tmp = dst[j]; 104 tmp &= mask; 105 tmp |= *src >> shift_low; 106 dst[j] = tmp; 107 tmp = *src << shift_high; 108 dst[j+1] = tmp; 109 src++; 110 } 111 tmp = dst[idx]; 112 tmp &= mask; 113 tmp |= *src >> shift_low; 114 dst[idx] = tmp; 115 if (shift_high < mod) { 116 tmp = *src << shift_high; 117 dst[idx+1] = tmp; 118 } 119 src++; 120 dst += d_pitch; 121 } 122} 123EXPORT_SYMBOL(fb_pad_unaligned_buffer); 124 125/* 126 * we need to lock this section since fb_cursor 127 * may use fb_imageblit() 128 */ 129char* fb_get_buffer_offset(struct fb_info *info, struct fb_pixmap *buf, u32 size) 130{ 131 u32 align = buf->buf_align - 1, offset; 132 char *addr = buf->addr; 133 134 /* If IO mapped, we need to sync before access, no sharing of 135 * the pixmap is done 136 */ 137 if (buf->flags & FB_PIXMAP_IO) { 138 if (info->fbops->fb_sync && (buf->flags & FB_PIXMAP_SYNC)) 139 info->fbops->fb_sync(info); 140 return addr; 141 } 142 143 /* See if we fit in the remaining pixmap space */ 144 offset = buf->offset + align; 145 offset &= ~align; 146 if (offset + size > buf->size) { 147 /* We do not fit. In order to be able to re-use the buffer, 148 * we must ensure no asynchronous DMA'ing or whatever operation 149 * is in progress, we sync for that. 150 */ 151 if (info->fbops->fb_sync && (buf->flags & FB_PIXMAP_SYNC)) 152 info->fbops->fb_sync(info); 153 offset = 0; 154 } 155 buf->offset = offset + size; 156 addr += offset; 157 158 return addr; 159} 160 161#ifdef CONFIG_LOGO 162 163static inline unsigned safe_shift(unsigned d, int n) 164{ 165 return n < 0 ? d >> -n : d << n; 166} 167 168static void fb_set_logocmap(struct fb_info *info, 169 const struct linux_logo *logo) 170{ 171 struct fb_cmap palette_cmap; 172 u16 palette_green[16]; 173 u16 palette_blue[16]; 174 u16 palette_red[16]; 175 int i, j, n; 176 const unsigned char *clut = logo->clut; 177 178 palette_cmap.start = 0; 179 palette_cmap.len = 16; 180 palette_cmap.red = palette_red; 181 palette_cmap.green = palette_green; 182 palette_cmap.blue = palette_blue; 183 palette_cmap.transp = NULL; 184 185 for (i = 0; i < logo->clutsize; i += n) { 186 n = logo->clutsize - i; 187 /* palette_cmap provides space for only 16 colors at once */ 188 if (n > 16) 189 n = 16; 190 palette_cmap.start = 32 + i; 191 palette_cmap.len = n; 192 for (j = 0; j < n; ++j) { 193 palette_cmap.red[j] = clut[0] << 8 | clut[0]; 194 palette_cmap.green[j] = clut[1] << 8 | clut[1]; 195 palette_cmap.blue[j] = clut[2] << 8 | clut[2]; 196 clut += 3; 197 } 198 fb_set_cmap(&palette_cmap, info); 199 } 200} 201 202static void fb_set_logo_truepalette(struct fb_info *info, 203 const struct linux_logo *logo, 204 u32 *palette) 205{ 206 static const unsigned char mask[] = { 0,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff }; 207 unsigned char redmask, greenmask, bluemask; 208 int redshift, greenshift, blueshift; 209 int i; 210 const unsigned char *clut = logo->clut; 211 212 /* 213 * We have to create a temporary palette since console palette is only 214 * 16 colors long. 215 */ 216 /* Bug: Doesn't obey msb_right ... (who needs that?) */ 217 redmask = mask[info->var.red.length < 8 ? info->var.red.length : 8]; 218 greenmask = mask[info->var.green.length < 8 ? info->var.green.length : 8]; 219 bluemask = mask[info->var.blue.length < 8 ? info->var.blue.length : 8]; 220 redshift = info->var.red.offset - (8 - info->var.red.length); 221 greenshift = info->var.green.offset - (8 - info->var.green.length); 222 blueshift = info->var.blue.offset - (8 - info->var.blue.length); 223 224 for ( i = 0; i < logo->clutsize; i++) { 225 palette[i+32] = (safe_shift((clut[0] & redmask), redshift) | 226 safe_shift((clut[1] & greenmask), greenshift) | 227 safe_shift((clut[2] & bluemask), blueshift)); 228 clut += 3; 229 } 230} 231 232static void fb_set_logo_directpalette(struct fb_info *info, 233 const struct linux_logo *logo, 234 u32 *palette) 235{ 236 int redshift, greenshift, blueshift; 237 int i; 238 239 redshift = info->var.red.offset; 240 greenshift = info->var.green.offset; 241 blueshift = info->var.blue.offset; 242 243 for (i = 32; i < 32 + logo->clutsize; i++) 244 palette[i] = i << redshift | i << greenshift | i << blueshift; 245} 246 247static void fb_set_logo(struct fb_info *info, 248 const struct linux_logo *logo, u8 *dst, 249 int depth) 250{ 251 int i, j, k; 252 const u8 *src = logo->data; 253 u8 xor = (info->fix.visual == FB_VISUAL_MONO01) ? 0xff : 0; 254 u8 fg = 1, d; 255 256 switch (fb_get_color_depth(&info->var, &info->fix)) { 257 case 1: 258 fg = 1; 259 break; 260 case 2: 261 fg = 3; 262 break; 263 default: 264 fg = 7; 265 break; 266 } 267 268 if (info->fix.visual == FB_VISUAL_MONO01 || 269 info->fix.visual == FB_VISUAL_MONO10) 270 fg = ~((u8) (0xfff << info->var.green.length)); 271 272 switch (depth) { 273 case 4: 274 for (i = 0; i < logo->height; i++) 275 for (j = 0; j < logo->width; src++) { 276 *dst++ = *src >> 4; 277 j++; 278 if (j < logo->width) { 279 *dst++ = *src & 0x0f; 280 j++; 281 } 282 } 283 break; 284 case 1: 285 for (i = 0; i < logo->height; i++) { 286 for (j = 0; j < logo->width; src++) { 287 d = *src ^ xor; 288 for (k = 7; k >= 0; k--) { 289 *dst++ = ((d >> k) & 1) ? fg : 0; 290 j++; 291 } 292 } 293 } 294 break; 295 } 296} 297 298/* 299 * Three (3) kinds of logo maps exist. linux_logo_clut224 (>16 colors), 300 * linux_logo_vga16 (16 colors) and linux_logo_mono (2 colors). Depending on 301 * the visual format and color depth of the framebuffer, the DAC, the 302 * pseudo_palette, and the logo data will be adjusted accordingly. 303 * 304 * Case 1 - linux_logo_clut224: 305 * Color exceeds the number of console colors (16), thus we set the hardware DAC 306 * using fb_set_cmap() appropriately. The "needs_cmapreset" flag will be set. 307 * 308 * For visuals that require color info from the pseudo_palette, we also construct 309 * one for temporary use. The "needs_directpalette" or "needs_truepalette" flags 310 * will be set. 311 * 312 * Case 2 - linux_logo_vga16: 313 * The number of colors just matches the console colors, thus there is no need 314 * to set the DAC or the pseudo_palette. However, the bitmap is packed, ie, 315 * each byte contains color information for two pixels (upper and lower nibble). 316 * To be consistent with fb_imageblit() usage, we therefore separate the two 317 * nibbles into separate bytes. The "depth" flag will be set to 4. 318 * 319 * Case 3 - linux_logo_mono: 320 * This is similar with Case 2. Each byte contains information for 8 pixels. 321 * We isolate each bit and expand each into a byte. The "depth" flag will 322 * be set to 1. 323 */ 324static struct logo_data { 325 int depth; 326 int needs_directpalette; 327 int needs_truepalette; 328 int needs_cmapreset; 329 const struct linux_logo *logo; 330} fb_logo __read_mostly; 331 332static void fb_rotate_logo_ud(const u8 *in, u8 *out, u32 width, u32 height) 333{ 334 u32 size = width * height, i; 335 336 out += size - 1; 337 338 for (i = size; i--; ) 339 *out-- = *in++; 340} 341 342static void fb_rotate_logo_cw(const u8 *in, u8 *out, u32 width, u32 height) 343{ 344 int i, j, h = height - 1; 345 346 for (i = 0; i < height; i++) 347 for (j = 0; j < width; j++) 348 out[height * j + h - i] = *in++; 349} 350 351static void fb_rotate_logo_ccw(const u8 *in, u8 *out, u32 width, u32 height) 352{ 353 int i, j, w = width - 1; 354 355 for (i = 0; i < height; i++) 356 for (j = 0; j < width; j++) 357 out[height * (w - j) + i] = *in++; 358} 359 360static void fb_rotate_logo(struct fb_info *info, u8 *dst, 361 struct fb_image *image, int rotate) 362{ 363 u32 tmp; 364 365 if (rotate == FB_ROTATE_UD) { 366 fb_rotate_logo_ud(image->data, dst, image->width, 367 image->height); 368 image->dx = info->var.xres - image->width - image->dx; 369 image->dy = info->var.yres - image->height - image->dy; 370 } else if (rotate == FB_ROTATE_CW) { 371 fb_rotate_logo_cw(image->data, dst, image->width, 372 image->height); 373 tmp = image->width; 374 image->width = image->height; 375 image->height = tmp; 376 tmp = image->dy; 377 image->dy = image->dx; 378 image->dx = info->var.xres - image->width - tmp; 379 } else if (rotate == FB_ROTATE_CCW) { 380 fb_rotate_logo_ccw(image->data, dst, image->width, 381 image->height); 382 tmp = image->width; 383 image->width = image->height; 384 image->height = tmp; 385 tmp = image->dx; 386 image->dx = image->dy; 387 image->dy = info->var.yres - image->height - tmp; 388 } 389 390 image->data = dst; 391} 392 393static void fb_do_show_logo(struct fb_info *info, struct fb_image *image, 394 int rotate, unsigned int num) 395{ 396 unsigned int x; 397 398 if (rotate == FB_ROTATE_UR) { 399 for (x = 0; 400 x < num && image->dx + image->width <= info->var.xres; 401 x++) { 402 info->fbops->fb_imageblit(info, image); 403 image->dx += image->width + 8; 404 } 405 } else if (rotate == FB_ROTATE_UD) { 406 for (x = 0; x < num && image->dx >= 0; x++) { 407 info->fbops->fb_imageblit(info, image); 408 image->dx -= image->width + 8; 409 } 410 } else if (rotate == FB_ROTATE_CW) { 411 for (x = 0; 412 x < num && image->dy + image->height <= info->var.yres; 413 x++) { 414 info->fbops->fb_imageblit(info, image); 415 image->dy += image->height + 8; 416 } 417 } else if (rotate == FB_ROTATE_CCW) { 418 for (x = 0; x < num && image->dy >= 0; x++) { 419 info->fbops->fb_imageblit(info, image); 420 image->dy -= image->height + 8; 421 } 422 } 423} 424 425static int fb_show_logo_line(struct fb_info *info, int rotate, 426 const struct linux_logo *logo, int y, 427 unsigned int n) 428{ 429 u32 *palette = NULL, *saved_pseudo_palette = NULL; 430 unsigned char *logo_new = NULL, *logo_rotate = NULL; 431 struct fb_image image; 432 433 /* Return if the frame buffer is not mapped or suspended */ 434 if (logo == NULL || info->state != FBINFO_STATE_RUNNING || 435 info->flags & FBINFO_MODULE) 436 return 0; 437 438 image.depth = 8; 439 image.data = logo->data; 440 441 if (fb_logo.needs_cmapreset) 442 fb_set_logocmap(info, logo); 443 444 if (fb_logo.needs_truepalette || 445 fb_logo.needs_directpalette) { 446 palette = kmalloc(256 * 4, GFP_KERNEL); 447 if (palette == NULL) 448 return 0; 449 450 if (fb_logo.needs_truepalette) 451 fb_set_logo_truepalette(info, logo, palette); 452 else 453 fb_set_logo_directpalette(info, logo, palette); 454 455 saved_pseudo_palette = info->pseudo_palette; 456 info->pseudo_palette = palette; 457 } 458 459 if (fb_logo.depth <= 4) { 460 logo_new = kmalloc(logo->width * logo->height, GFP_KERNEL); 461 if (logo_new == NULL) { 462 kfree(palette); 463 if (saved_pseudo_palette) 464 info->pseudo_palette = saved_pseudo_palette; 465 return 0; 466 } 467 image.data = logo_new; 468 fb_set_logo(info, logo, logo_new, fb_logo.depth); 469 } 470 471 image.dx = 0; 472 image.dy = y; 473 image.width = logo->width; 474 image.height = logo->height; 475 476 if (rotate) { 477 logo_rotate = kmalloc(logo->width * 478 logo->height, GFP_KERNEL); 479 if (logo_rotate) 480 fb_rotate_logo(info, logo_rotate, &image, rotate); 481 } 482 483 fb_do_show_logo(info, &image, rotate, n); 484 485 kfree(palette); 486 if (saved_pseudo_palette != NULL) 487 info->pseudo_palette = saved_pseudo_palette; 488 kfree(logo_new); 489 kfree(logo_rotate); 490 return logo->height; 491} 492 493 494#ifdef CONFIG_FB_LOGO_EXTRA 495 496#define FB_LOGO_EX_NUM_MAX 10 497static struct logo_data_extra { 498 const struct linux_logo *logo; 499 unsigned int n; 500} fb_logo_ex[FB_LOGO_EX_NUM_MAX]; 501static unsigned int fb_logo_ex_num; 502 503void fb_append_extra_logo(const struct linux_logo *logo, unsigned int n) 504{ 505 if (!n || fb_logo_ex_num == FB_LOGO_EX_NUM_MAX) 506 return; 507 508 fb_logo_ex[fb_logo_ex_num].logo = logo; 509 fb_logo_ex[fb_logo_ex_num].n = n; 510 fb_logo_ex_num++; 511} 512 513static int fb_prepare_extra_logos(struct fb_info *info, unsigned int height, 514 unsigned int yres) 515{ 516 unsigned int i; 517 518 if (info->fix.visual != FB_VISUAL_TRUECOLOR) 519 fb_logo_ex_num = 0; 520 521 for (i = 0; i < fb_logo_ex_num; i++) { 522 if (fb_logo_ex[i].logo->type != fb_logo.logo->type) { 523 fb_logo_ex[i].logo = NULL; 524 continue; 525 } 526 height += fb_logo_ex[i].logo->height; 527 if (height > yres) { 528 height -= fb_logo_ex[i].logo->height; 529 fb_logo_ex_num = i; 530 break; 531 } 532 } 533 return height; 534} 535 536static int fb_show_extra_logos(struct fb_info *info, int y, int rotate) 537{ 538 unsigned int i; 539 540 for (i = 0; i < fb_logo_ex_num; i++) 541 y += fb_show_logo_line(info, rotate, 542 fb_logo_ex[i].logo, y, fb_logo_ex[i].n); 543 544 return y; 545} 546 547#else /* !CONFIG_FB_LOGO_EXTRA */ 548 549static inline int fb_prepare_extra_logos(struct fb_info *info, 550 unsigned int height, 551 unsigned int yres) 552{ 553 return height; 554} 555 556static inline int fb_show_extra_logos(struct fb_info *info, int y, int rotate) 557{ 558 return y; 559} 560 561#endif /* CONFIG_FB_LOGO_EXTRA */ 562 563 564int fb_prepare_logo(struct fb_info *info, int rotate) 565{ 566 int depth = fb_get_color_depth(&info->var, &info->fix); 567 unsigned int yres; 568 569 memset(&fb_logo, 0, sizeof(struct logo_data)); 570 571 if (info->flags & FBINFO_MISC_TILEBLITTING || 572 info->flags & FBINFO_MODULE) 573 return 0; 574 575 if (info->fix.visual == FB_VISUAL_DIRECTCOLOR) { 576 depth = info->var.blue.length; 577 if (info->var.red.length < depth) 578 depth = info->var.red.length; 579 if (info->var.green.length < depth) 580 depth = info->var.green.length; 581 } 582 583 if (info->fix.visual == FB_VISUAL_STATIC_PSEUDOCOLOR && depth > 4) { 584 /* assume console colormap */ 585 depth = 4; 586 } 587 588 /* Return if no suitable logo was found */ 589 fb_logo.logo = fb_find_logo(depth); 590 591 if (!fb_logo.logo) { 592 return 0; 593 } 594 595 if (rotate == FB_ROTATE_UR || rotate == FB_ROTATE_UD) 596 yres = info->var.yres; 597 else 598 yres = info->var.xres; 599 600 if (fb_logo.logo->height > yres) { 601 fb_logo.logo = NULL; 602 return 0; 603 } 604 605 /* What depth we asked for might be different from what we get */ 606 if (fb_logo.logo->type == LINUX_LOGO_CLUT224) 607 fb_logo.depth = 8; 608 else if (fb_logo.logo->type == LINUX_LOGO_VGA16) 609 fb_logo.depth = 4; 610 else 611 fb_logo.depth = 1; 612 613 614 if (fb_logo.depth > 4 && depth > 4) { 615 switch (info->fix.visual) { 616 case FB_VISUAL_TRUECOLOR: 617 fb_logo.needs_truepalette = 1; 618 break; 619 case FB_VISUAL_DIRECTCOLOR: 620 fb_logo.needs_directpalette = 1; 621 fb_logo.needs_cmapreset = 1; 622 break; 623 case FB_VISUAL_PSEUDOCOLOR: 624 fb_logo.needs_cmapreset = 1; 625 break; 626 } 627 } 628 629 return fb_prepare_extra_logos(info, fb_logo.logo->height, yres); 630} 631 632int fb_show_logo(struct fb_info *info, int rotate) 633{ 634 int y; 635 636 y = fb_show_logo_line(info, rotate, fb_logo.logo, 0, 637 num_online_cpus()); 638 y = fb_show_extra_logos(info, y, rotate); 639 640 return y; 641} 642#else 643int fb_prepare_logo(struct fb_info *info, int rotate) { return 0; } 644int fb_show_logo(struct fb_info *info, int rotate) { return 0; } 645#endif /* CONFIG_LOGO */ 646 647static void *fb_seq_start(struct seq_file *m, loff_t *pos) 648{ 649 return (*pos < FB_MAX) ? pos : NULL; 650} 651 652static void *fb_seq_next(struct seq_file *m, void *v, loff_t *pos) 653{ 654 (*pos)++; 655 return (*pos < FB_MAX) ? pos : NULL; 656} 657 658static void fb_seq_stop(struct seq_file *m, void *v) 659{ 660} 661 662static int fb_seq_show(struct seq_file *m, void *v) 663{ 664 int i = *(loff_t *)v; 665 struct fb_info *fi = registered_fb[i]; 666 667 if (fi) 668 seq_printf(m, "%d %s\n", fi->node, fi->fix.id); 669 return 0; 670} 671 672static const struct seq_operations proc_fb_seq_ops = { 673 .start = fb_seq_start, 674 .next = fb_seq_next, 675 .stop = fb_seq_stop, 676 .show = fb_seq_show, 677}; 678 679static int proc_fb_open(struct inode *inode, struct file *file) 680{ 681 return seq_open(file, &proc_fb_seq_ops); 682} 683 684static const struct file_operations fb_proc_fops = { 685 .owner = THIS_MODULE, 686 .open = proc_fb_open, 687 .read = seq_read, 688 .llseek = seq_lseek, 689 .release = seq_release, 690}; 691 692static ssize_t 693fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) 694{ 695 unsigned long p = *ppos; 696 struct inode *inode = file->f_path.dentry->d_inode; 697 int fbidx = iminor(inode); 698 struct fb_info *info = registered_fb[fbidx]; 699 u32 *buffer, *dst; 700 u32 __iomem *src; 701 int c, i, cnt = 0, err = 0; 702 unsigned long total_size; 703 704 if (!info || ! info->screen_base) 705 return -ENODEV; 706 707 if (info->state != FBINFO_STATE_RUNNING) 708 return -EPERM; 709 710 if (info->fbops->fb_read) 711 return info->fbops->fb_read(info, buf, count, ppos); 712 713 total_size = info->screen_size; 714 715 if (total_size == 0) 716 total_size = info->fix.smem_len; 717 718 if (p >= total_size) 719 return 0; 720 721 if (count >= total_size) 722 count = total_size; 723 724 if (count + p > total_size) 725 count = total_size - p; 726 727 buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count, 728 GFP_KERNEL); 729 if (!buffer) 730 return -ENOMEM; 731 732 src = (u32 __iomem *) (info->screen_base + p); 733 734 if (info->fbops->fb_sync) 735 info->fbops->fb_sync(info); 736 737 while (count) { 738 c = (count > PAGE_SIZE) ? PAGE_SIZE : count; 739 dst = buffer; 740 for (i = c >> 2; i--; ) 741 *dst++ = fb_readl(src++); 742 if (c & 3) { 743 u8 *dst8 = (u8 *) dst; 744 u8 __iomem *src8 = (u8 __iomem *) src; 745 746 for (i = c & 3; i--;) 747 *dst8++ = fb_readb(src8++); 748 749 src = (u32 __iomem *) src8; 750 } 751 752 if (copy_to_user(buf, buffer, c)) { 753 err = -EFAULT; 754 break; 755 } 756 *ppos += c; 757 buf += c; 758 cnt += c; 759 count -= c; 760 } 761 762 kfree(buffer); 763 764 return (err) ? err : cnt; 765} 766 767static ssize_t 768fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) 769{ 770 unsigned long p = *ppos; 771 struct inode *inode = file->f_path.dentry->d_inode; 772 int fbidx = iminor(inode); 773 struct fb_info *info = registered_fb[fbidx]; 774 u32 *buffer, *src; 775 u32 __iomem *dst; 776 int c, i, cnt = 0, err = 0; 777 unsigned long total_size; 778 779 if (!info || !info->screen_base) 780 return -ENODEV; 781 782 if (info->state != FBINFO_STATE_RUNNING) 783 return -EPERM; 784 785 if (info->fbops->fb_write) 786 return info->fbops->fb_write(info, buf, count, ppos); 787 788 total_size = info->screen_size; 789 790 if (total_size == 0) 791 total_size = info->fix.smem_len; 792 793 if (p > total_size) 794 return -EFBIG; 795 796 if (count > total_size) { 797 err = -EFBIG; 798 count = total_size; 799 } 800 801 if (count + p > total_size) { 802 if (!err) 803 err = -ENOSPC; 804 805 count = total_size - p; 806 } 807 808 buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count, 809 GFP_KERNEL); 810 if (!buffer) 811 return -ENOMEM; 812 813 dst = (u32 __iomem *) (info->screen_base + p); 814 815 if (info->fbops->fb_sync) 816 info->fbops->fb_sync(info); 817 818 while (count) { 819 c = (count > PAGE_SIZE) ? PAGE_SIZE : count; 820 src = buffer; 821 822 if (copy_from_user(src, buf, c)) { 823 err = -EFAULT; 824 break; 825 } 826 827 for (i = c >> 2; i--; ) 828 fb_writel(*src++, dst++); 829 830 if (c & 3) { 831 u8 *src8 = (u8 *) src; 832 u8 __iomem *dst8 = (u8 __iomem *) dst; 833 834 for (i = c & 3; i--; ) 835 fb_writeb(*src8++, dst8++); 836 837 dst = (u32 __iomem *) dst8; 838 } 839 840 *ppos += c; 841 buf += c; 842 cnt += c; 843 count -= c; 844 } 845 846 kfree(buffer); 847 848 return (cnt) ? cnt : err; 849} 850 851int 852fb_pan_display(struct fb_info *info, struct fb_var_screeninfo *var) 853{ 854 struct fb_fix_screeninfo *fix = &info->fix; 855 unsigned int yres = info->var.yres; 856 int err = 0; 857 858 if (var->yoffset > 0) { 859 if (var->vmode & FB_VMODE_YWRAP) { 860 if (!fix->ywrapstep || (var->yoffset % fix->ywrapstep)) 861 err = -EINVAL; 862 else 863 yres = 0; 864 } else if (!fix->ypanstep || (var->yoffset % fix->ypanstep)) 865 err = -EINVAL; 866 } 867 868 if (var->xoffset > 0 && (!fix->xpanstep || 869 (var->xoffset % fix->xpanstep))) 870 err = -EINVAL; 871 872 if (err || !info->fbops->fb_pan_display || 873 var->yoffset > info->var.yres_virtual - yres || 874 var->xoffset > info->var.xres_virtual - info->var.xres) 875 return -EINVAL; 876 877 if ((err = info->fbops->fb_pan_display(var, info))) 878 return err; 879 info->var.xoffset = var->xoffset; 880 info->var.yoffset = var->yoffset; 881 if (var->vmode & FB_VMODE_YWRAP) 882 info->var.vmode |= FB_VMODE_YWRAP; 883 else 884 info->var.vmode &= ~FB_VMODE_YWRAP; 885 return 0; 886} 887 888static int fb_check_caps(struct fb_info *info, struct fb_var_screeninfo *var, 889 u32 activate) 890{ 891 struct fb_event event; 892 struct fb_blit_caps caps, fbcaps; 893 int err = 0; 894 895 memset(&caps, 0, sizeof(caps)); 896 memset(&fbcaps, 0, sizeof(fbcaps)); 897 caps.flags = (activate & FB_ACTIVATE_ALL) ? 1 : 0; 898 event.info = info; 899 event.data = ∩︀ 900 fb_notifier_call_chain(FB_EVENT_GET_REQ, &event); 901 info->fbops->fb_get_caps(info, &fbcaps, var); 902 903 if (((fbcaps.x ^ caps.x) & caps.x) || 904 ((fbcaps.y ^ caps.y) & caps.y) || 905 (fbcaps.len < caps.len)) 906 err = -EINVAL; 907 908 return err; 909} 910 911int 912fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var) 913{ 914 int flags = info->flags; 915 int ret = 0; 916 917 if (var->activate & FB_ACTIVATE_INV_MODE) { 918 struct fb_videomode mode1, mode2; 919 920 fb_var_to_videomode(&mode1, var); 921 fb_var_to_videomode(&mode2, &info->var); 922 /* make sure we don't delete the videomode of current var */ 923 ret = fb_mode_is_equal(&mode1, &mode2); 924 925 if (!ret) { 926 struct fb_event event; 927 928 event.info = info; 929 event.data = &mode1; 930 ret = fb_notifier_call_chain(FB_EVENT_MODE_DELETE, &event); 931 } 932 933 if (!ret) 934 fb_delete_videomode(&mode1, &info->modelist); 935 936 937 ret = (ret) ? -EINVAL : 0; 938 goto done; 939 } 940 941 if ((var->activate & FB_ACTIVATE_FORCE) || 942 memcmp(&info->var, var, sizeof(struct fb_var_screeninfo))) { 943 u32 activate = var->activate; 944 945 if (!info->fbops->fb_check_var) { 946 *var = info->var; 947 goto done; 948 } 949 950 ret = info->fbops->fb_check_var(var, info); 951 952 if (ret) 953 goto done; 954 955 if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) { 956 struct fb_var_screeninfo old_var; 957 struct fb_videomode mode; 958 959 if (info->fbops->fb_get_caps) { 960 ret = fb_check_caps(info, var, activate); 961 962 if (ret) 963 goto done; 964 } 965 966 old_var = info->var; 967 info->var = *var; 968 969 if (info->fbops->fb_set_par) { 970 ret = info->fbops->fb_set_par(info); 971 972 if (ret) { 973 info->var = old_var; 974 printk(KERN_WARNING "detected " 975 "fb_set_par error, " 976 "error code: %d\n", ret); 977 goto done; 978 } 979 } 980 981 fb_pan_display(info, &info->var); 982 fb_set_cmap(&info->cmap, info); 983 fb_var_to_videomode(&mode, &info->var); 984 985 if (info->modelist.prev && info->modelist.next && 986 !list_empty(&info->modelist)) 987 ret = fb_add_videomode(&mode, &info->modelist); 988 989 if (!ret && (flags & FBINFO_MISC_USEREVENT)) { 990 struct fb_event event; 991 int evnt = (activate & FB_ACTIVATE_ALL) ? 992 FB_EVENT_MODE_CHANGE_ALL : 993 FB_EVENT_MODE_CHANGE; 994 995 info->flags &= ~FBINFO_MISC_USEREVENT; 996 event.info = info; 997 event.data = &mode; 998 fb_notifier_call_chain(evnt, &event); 999 } 1000 } 1001 } 1002 1003 done: 1004 return ret; 1005} 1006 1007int 1008fb_blank(struct fb_info *info, int blank) 1009{ 1010 int ret = -EINVAL; 1011 1012 if (blank > FB_BLANK_POWERDOWN) 1013 blank = FB_BLANK_POWERDOWN; 1014 1015 if (info->fbops->fb_blank) 1016 ret = info->fbops->fb_blank(blank, info); 1017 1018 if (!ret) { 1019 struct fb_event event; 1020 1021 event.info = info; 1022 event.data = ␣ 1023 fb_notifier_call_chain(FB_EVENT_BLANK, &event); 1024 } 1025 1026 return ret; 1027} 1028 1029static long do_fb_ioctl(struct fb_info *info, unsigned int cmd, 1030 unsigned long arg) 1031{ 1032 struct fb_ops *fb; 1033 struct fb_var_screeninfo var; 1034 struct fb_fix_screeninfo fix; 1035 struct fb_con2fbmap con2fb; 1036 struct fb_cmap cmap_from; 1037 struct fb_cmap_user cmap; 1038 struct fb_event event; 1039 void __user *argp = (void __user *)arg; 1040 long ret = 0; 1041 1042 switch (cmd) { 1043 case FBIOGET_VSCREENINFO: 1044 if (!lock_fb_info(info)) 1045 return -ENODEV; 1046 var = info->var; 1047 unlock_fb_info(info); 1048 1049 ret = copy_to_user(argp, &var, sizeof(var)) ? -EFAULT : 0; 1050 break; 1051 case FBIOPUT_VSCREENINFO: 1052 if (copy_from_user(&var, argp, sizeof(var))) 1053 return -EFAULT; 1054 if (!lock_fb_info(info)) 1055 return -ENODEV; 1056 acquire_console_sem(); 1057 info->flags |= FBINFO_MISC_USEREVENT; 1058 ret = fb_set_var(info, &var); 1059 info->flags &= ~FBINFO_MISC_USEREVENT; 1060 release_console_sem(); 1061 unlock_fb_info(info); 1062 if (!ret && copy_to_user(argp, &var, sizeof(var))) 1063 ret = -EFAULT; 1064 break; 1065 case FBIOGET_FSCREENINFO: 1066 if (!lock_fb_info(info)) 1067 return -ENODEV; 1068 fix = info->fix; 1069 unlock_fb_info(info); 1070 1071 ret = copy_to_user(argp, &fix, sizeof(fix)) ? -EFAULT : 0; 1072 break; 1073 case FBIOPUTCMAP: 1074 if (copy_from_user(&cmap, argp, sizeof(cmap))) 1075 return -EFAULT; 1076 ret = fb_set_user_cmap(&cmap, info); 1077 break; 1078 case FBIOGETCMAP: 1079 if (copy_from_user(&cmap, argp, sizeof(cmap))) 1080 return -EFAULT; 1081 if (!lock_fb_info(info)) 1082 return -ENODEV; 1083 cmap_from = info->cmap; 1084 unlock_fb_info(info); 1085 ret = fb_cmap_to_user(&cmap_from, &cmap); 1086 break; 1087 case FBIOPAN_DISPLAY: 1088 if (copy_from_user(&var, argp, sizeof(var))) 1089 return -EFAULT; 1090 if (!lock_fb_info(info)) 1091 return -ENODEV; 1092 acquire_console_sem(); 1093 ret = fb_pan_display(info, &var); 1094 release_console_sem(); 1095 unlock_fb_info(info); 1096 if (ret == 0 && copy_to_user(argp, &var, sizeof(var))) 1097 return -EFAULT; 1098 break; 1099 case FBIO_CURSOR: 1100 ret = -EINVAL; 1101 break; 1102 case FBIOGET_CON2FBMAP: 1103 if (copy_from_user(&con2fb, argp, sizeof(con2fb))) 1104 return -EFAULT; 1105 if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES) 1106 return -EINVAL; 1107 con2fb.framebuffer = -1; 1108 event.data = &con2fb; 1109 if (!lock_fb_info(info)) 1110 return -ENODEV; 1111 event.info = info; 1112 fb_notifier_call_chain(FB_EVENT_GET_CONSOLE_MAP, &event); 1113 unlock_fb_info(info); 1114 ret = copy_to_user(argp, &con2fb, sizeof(con2fb)) ? -EFAULT : 0; 1115 break; 1116 case FBIOPUT_CON2FBMAP: 1117 if (copy_from_user(&con2fb, argp, sizeof(con2fb))) 1118 return -EFAULT; 1119 if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES) 1120 return -EINVAL; 1121 if (con2fb.framebuffer < 0 || con2fb.framebuffer >= FB_MAX) 1122 return -EINVAL; 1123 if (!registered_fb[con2fb.framebuffer]) 1124 request_module("fb%d", con2fb.framebuffer); 1125 if (!registered_fb[con2fb.framebuffer]) { 1126 ret = -EINVAL; 1127 break; 1128 } 1129 event.data = &con2fb; 1130 if (!lock_fb_info(info)) 1131 return -ENODEV; 1132 event.info = info; 1133 ret = fb_notifier_call_chain(FB_EVENT_SET_CONSOLE_MAP, &event); 1134 unlock_fb_info(info); 1135 break; 1136 case FBIOBLANK: 1137 if (!lock_fb_info(info)) 1138 return -ENODEV; 1139 acquire_console_sem(); 1140 info->flags |= FBINFO_MISC_USEREVENT; 1141 ret = fb_blank(info, arg); 1142 info->flags &= ~FBINFO_MISC_USEREVENT; 1143 release_console_sem(); 1144 unlock_fb_info(info); 1145 break; 1146 default: 1147 if (!lock_fb_info(info)) 1148 return -ENODEV; 1149 fb = info->fbops; 1150 if (fb->fb_ioctl) 1151 ret = fb->fb_ioctl(info, cmd, arg); 1152 else 1153 ret = -ENOTTY; 1154 unlock_fb_info(info); 1155 } 1156 return ret; 1157} 1158 1159static long fb_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 1160{ 1161 struct inode *inode = file->f_path.dentry->d_inode; 1162 int fbidx = iminor(inode); 1163 struct fb_info *info = registered_fb[fbidx]; 1164 1165 return do_fb_ioctl(info, cmd, arg); 1166} 1167 1168#ifdef CONFIG_COMPAT 1169struct fb_fix_screeninfo32 { 1170 char id[16]; 1171 compat_caddr_t smem_start; 1172 u32 smem_len; 1173 u32 type; 1174 u32 type_aux; 1175 u32 visual; 1176 u16 xpanstep; 1177 u16 ypanstep; 1178 u16 ywrapstep; 1179 u32 line_length; 1180 compat_caddr_t mmio_start; 1181 u32 mmio_len; 1182 u32 accel; 1183 u16 reserved[3]; 1184}; 1185 1186struct fb_cmap32 { 1187 u32 start; 1188 u32 len; 1189 compat_caddr_t red; 1190 compat_caddr_t green; 1191 compat_caddr_t blue; 1192 compat_caddr_t transp; 1193}; 1194 1195static int fb_getput_cmap(struct fb_info *info, unsigned int cmd, 1196 unsigned long arg) 1197{ 1198 struct fb_cmap_user __user *cmap; 1199 struct fb_cmap32 __user *cmap32; 1200 __u32 data; 1201 int err; 1202 1203 cmap = compat_alloc_user_space(sizeof(*cmap)); 1204 cmap32 = compat_ptr(arg); 1205 1206 if (copy_in_user(&cmap->start, &cmap32->start, 2 * sizeof(__u32))) 1207 return -EFAULT; 1208 1209 if (get_user(data, &cmap32->red) || 1210 put_user(compat_ptr(data), &cmap->red) || 1211 get_user(data, &cmap32->green) || 1212 put_user(compat_ptr(data), &cmap->green) || 1213 get_user(data, &cmap32->blue) || 1214 put_user(compat_ptr(data), &cmap->blue) || 1215 get_user(data, &cmap32->transp) || 1216 put_user(compat_ptr(data), &cmap->transp)) 1217 return -EFAULT; 1218 1219 err = do_fb_ioctl(info, cmd, (unsigned long) cmap); 1220 1221 if (!err) { 1222 if (copy_in_user(&cmap32->start, 1223 &cmap->start, 1224 2 * sizeof(__u32))) 1225 err = -EFAULT; 1226 } 1227 return err; 1228} 1229 1230static int do_fscreeninfo_to_user(struct fb_fix_screeninfo *fix, 1231 struct fb_fix_screeninfo32 __user *fix32) 1232{ 1233 __u32 data; 1234 int err; 1235 1236 err = copy_to_user(&fix32->id, &fix->id, sizeof(fix32->id)); 1237 1238 data = (__u32) (unsigned long) fix->smem_start; 1239 err |= put_user(data, &fix32->smem_start); 1240 1241 err |= put_user(fix->smem_len, &fix32->smem_len); 1242 err |= put_user(fix->type, &fix32->type); 1243 err |= put_user(fix->type_aux, &fix32->type_aux); 1244 err |= put_user(fix->visual, &fix32->visual); 1245 err |= put_user(fix->xpanstep, &fix32->xpanstep); 1246 err |= put_user(fix->ypanstep, &fix32->ypanstep); 1247 err |= put_user(fix->ywrapstep, &fix32->ywrapstep); 1248 err |= put_user(fix->line_length, &fix32->line_length); 1249 1250 data = (__u32) (unsigned long) fix->mmio_start; 1251 err |= put_user(data, &fix32->mmio_start); 1252 1253 err |= put_user(fix->mmio_len, &fix32->mmio_len); 1254 err |= put_user(fix->accel, &fix32->accel); 1255 err |= copy_to_user(fix32->reserved, fix->reserved, 1256 sizeof(fix->reserved)); 1257 1258 return err; 1259} 1260 1261static int fb_get_fscreeninfo(struct fb_info *info, unsigned int cmd, 1262 unsigned long arg) 1263{ 1264 mm_segment_t old_fs; 1265 struct fb_fix_screeninfo fix; 1266 struct fb_fix_screeninfo32 __user *fix32; 1267 int err; 1268 1269 fix32 = compat_ptr(arg); 1270 1271 old_fs = get_fs(); 1272 set_fs(KERNEL_DS); 1273 err = do_fb_ioctl(info, cmd, (unsigned long) &fix); 1274 set_fs(old_fs); 1275 1276 if (!err) 1277 err = do_fscreeninfo_to_user(&fix, fix32); 1278 1279 return err; 1280} 1281 1282static long fb_compat_ioctl(struct file *file, unsigned int cmd, 1283 unsigned long arg) 1284{ 1285 struct inode *inode = file->f_path.dentry->d_inode; 1286 int fbidx = iminor(inode); 1287 struct fb_info *info = registered_fb[fbidx]; 1288 struct fb_ops *fb = info->fbops; 1289 long ret = -ENOIOCTLCMD; 1290 1291 switch(cmd) { 1292 case FBIOGET_VSCREENINFO: 1293 case FBIOPUT_VSCREENINFO: 1294 case FBIOPAN_DISPLAY: 1295 case FBIOGET_CON2FBMAP: 1296 case FBIOPUT_CON2FBMAP: 1297 arg = (unsigned long) compat_ptr(arg); 1298 case FBIOBLANK: 1299 ret = do_fb_ioctl(info, cmd, arg); 1300 break; 1301 1302 case FBIOGET_FSCREENINFO: 1303 ret = fb_get_fscreeninfo(info, cmd, arg); 1304 break; 1305 1306 case FBIOGETCMAP: 1307 case FBIOPUTCMAP: 1308 ret = fb_getput_cmap(info, cmd, arg); 1309 break; 1310 1311 default: 1312 if (fb->fb_compat_ioctl) 1313 ret = fb->fb_compat_ioctl(info, cmd, arg); 1314 break; 1315 } 1316 return ret; 1317} 1318#endif 1319 1320static int 1321fb_mmap(struct file *file, struct vm_area_struct * vma) 1322{ 1323 int fbidx = iminor(file->f_path.dentry->d_inode); 1324 struct fb_info *info = registered_fb[fbidx]; 1325 struct fb_ops *fb = info->fbops; 1326 unsigned long off; 1327 unsigned long start; 1328 u32 len; 1329 1330 if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT)) 1331 return -EINVAL; 1332 off = vma->vm_pgoff << PAGE_SHIFT; 1333 if (!fb) 1334 return -ENODEV; 1335 mutex_lock(&info->mm_lock); 1336 if (fb->fb_mmap) { 1337 int res; 1338 res = fb->fb_mmap(info, vma); 1339 mutex_unlock(&info->mm_lock); 1340 return res; 1341 } 1342 1343 /* frame buffer memory */ 1344 start = info->fix.smem_start; 1345 len = PAGE_ALIGN((start & ~PAGE_MASK) + info->fix.smem_len); 1346 if (off >= len) { 1347 /* memory mapped io */ 1348 off -= len; 1349 if (info->var.accel_flags) { 1350 mutex_unlock(&info->mm_lock); 1351 return -EINVAL; 1352 } 1353 start = info->fix.mmio_start; 1354 len = PAGE_ALIGN((start & ~PAGE_MASK) + info->fix.mmio_len); 1355 } 1356 mutex_unlock(&info->mm_lock); 1357 start &= PAGE_MASK; 1358 if ((vma->vm_end - vma->vm_start + off) > len) 1359 return -EINVAL; 1360 off += start; 1361 vma->vm_pgoff = off >> PAGE_SHIFT; 1362 /* This is an IO map - tell maydump to skip this VMA */ 1363 vma->vm_flags |= VM_IO | VM_RESERVED; 1364 vma->vm_page_prot = vm_get_page_prot(vma->vm_flags); 1365 fb_pgprotect(file, vma, off); 1366 if (io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT, 1367 vma->vm_end - vma->vm_start, vma->vm_page_prot)) 1368 return -EAGAIN; 1369 return 0; 1370} 1371 1372static int 1373fb_open(struct inode *inode, struct file *file) 1374__acquires(&info->lock) 1375__releases(&info->lock) 1376{ 1377 int fbidx = iminor(inode); 1378 struct fb_info *info; 1379 int res = 0; 1380 1381 if (fbidx >= FB_MAX) 1382 return -ENODEV; 1383 info = registered_fb[fbidx]; 1384 if (!info) 1385 request_module("fb%d", fbidx); 1386 info = registered_fb[fbidx]; 1387 if (!info) 1388 return -ENODEV; 1389 mutex_lock(&info->lock); 1390 if (!try_module_get(info->fbops->owner)) { 1391 res = -ENODEV; 1392 goto out; 1393 } 1394 file->private_data = info; 1395 if (info->fbops->fb_open) { 1396 res = info->fbops->fb_open(info,1); 1397 if (res) 1398 module_put(info->fbops->owner); 1399 } 1400#ifdef CONFIG_FB_DEFERRED_IO 1401 if (info->fbdefio) 1402 fb_deferred_io_open(info, inode, file); 1403#endif 1404out: 1405 mutex_unlock(&info->lock); 1406 return res; 1407} 1408 1409static int 1410fb_release(struct inode *inode, struct file *file) 1411__acquires(&info->lock) 1412__releases(&info->lock) 1413{ 1414 struct fb_info * const info = file->private_data; 1415 1416 mutex_lock(&info->lock); 1417 if (info->fbops->fb_release) 1418 info->fbops->fb_release(info,1); 1419 module_put(info->fbops->owner); 1420 mutex_unlock(&info->lock); 1421 return 0; 1422} 1423 1424static const struct file_operations fb_fops = { 1425 .owner = THIS_MODULE, 1426 .read = fb_read, 1427 .write = fb_write, 1428 .unlocked_ioctl = fb_ioctl, 1429#ifdef CONFIG_COMPAT 1430 .compat_ioctl = fb_compat_ioctl, 1431#endif 1432 .mmap = fb_mmap, 1433 .open = fb_open, 1434 .release = fb_release, 1435#ifdef HAVE_ARCH_FB_UNMAPPED_AREA 1436 .get_unmapped_area = get_fb_unmapped_area, 1437#endif 1438#ifdef CONFIG_FB_DEFERRED_IO 1439 .fsync = fb_deferred_io_fsync, 1440#endif 1441}; 1442 1443struct class *fb_class; 1444EXPORT_SYMBOL(fb_class); 1445 1446static int fb_check_foreignness(struct fb_info *fi) 1447{ 1448 const bool foreign_endian = fi->flags & FBINFO_FOREIGN_ENDIAN; 1449 1450 fi->flags &= ~FBINFO_FOREIGN_ENDIAN; 1451 1452#ifdef __BIG_ENDIAN 1453 fi->flags |= foreign_endian ? 0 : FBINFO_BE_MATH; 1454#else 1455 fi->flags |= foreign_endian ? FBINFO_BE_MATH : 0; 1456#endif /* __BIG_ENDIAN */ 1457 1458 if (fi->flags & FBINFO_BE_MATH && !fb_be_math(fi)) { 1459 pr_err("%s: enable CONFIG_FB_BIG_ENDIAN to " 1460 "support this framebuffer\n", fi->fix.id); 1461 return -ENOSYS; 1462 } else if (!(fi->flags & FBINFO_BE_MATH) && fb_be_math(fi)) { 1463 pr_err("%s: enable CONFIG_FB_LITTLE_ENDIAN to " 1464 "support this framebuffer\n", fi->fix.id); 1465 return -ENOSYS; 1466 } 1467 1468 return 0; 1469} 1470 1471static bool apertures_overlap(struct aperture *gen, struct aperture *hw) 1472{ 1473 /* is the generic aperture base the same as the HW one */ 1474 if (gen->base == hw->base) 1475 return true; 1476 /* is the generic aperture base inside the hw base->hw base+size */ 1477 if (gen->base > hw->base && gen->base <= hw->base + hw->size) 1478 return true; 1479 return false; 1480} 1481 1482static bool fb_do_apertures_overlap(struct apertures_struct *gena, 1483 struct apertures_struct *hwa) 1484{ 1485 int i, j; 1486 if (!hwa || !gena) 1487 return false; 1488 1489 for (i = 0; i < hwa->count; ++i) { 1490 struct aperture *h = &hwa->ranges[i]; 1491 for (j = 0; j < gena->count; ++j) { 1492 struct aperture *g = &gena->ranges[j]; 1493 printk(KERN_DEBUG "checking generic (%llx %llx) vs hw (%llx %llx)\n", 1494 (unsigned long long)g->base, 1495 (unsigned long long)g->size, 1496 (unsigned long long)h->base, 1497 (unsigned long long)h->size); 1498 if (apertures_overlap(g, h)) 1499 return true; 1500 } 1501 } 1502 1503 return false; 1504} 1505 1506#define VGA_FB_PHYS 0xA0000 1507void remove_conflicting_framebuffers(struct apertures_struct *a, 1508 const char *name, bool primary) 1509{ 1510 int i; 1511 1512 /* check all firmware fbs and kick off if the base addr overlaps */ 1513 for (i = 0 ; i < FB_MAX; i++) { 1514 struct apertures_struct *gen_aper; 1515 if (!registered_fb[i]) 1516 continue; 1517 1518 if (!(registered_fb[i]->flags & FBINFO_MISC_FIRMWARE)) 1519 continue; 1520 1521 gen_aper = registered_fb[i]->apertures; 1522 if (fb_do_apertures_overlap(gen_aper, a) || 1523 (primary && gen_aper && gen_aper->count && 1524 gen_aper->ranges[0].base == VGA_FB_PHYS)) { 1525 1526 printk(KERN_ERR "fb: conflicting fb hw usage " 1527 "%s vs %s - removing generic driver\n", 1528 name, registered_fb[i]->fix.id); 1529 unregister_framebuffer(registered_fb[i]); 1530 } 1531 } 1532} 1533EXPORT_SYMBOL(remove_conflicting_framebuffers); 1534 1535/** 1536 * register_framebuffer - registers a frame buffer device 1537 * @fb_info: frame buffer info structure 1538 * 1539 * Registers a frame buffer device @fb_info. 1540 * 1541 * Returns negative errno on error, or zero for success. 1542 * 1543 */ 1544 1545int 1546register_framebuffer(struct fb_info *fb_info) 1547{ 1548 int i; 1549 struct fb_event event; 1550 struct fb_videomode mode; 1551 1552 if (num_registered_fb == FB_MAX) 1553 return -ENXIO; 1554 1555 if (fb_check_foreignness(fb_info)) 1556 return -ENOSYS; 1557 1558 remove_conflicting_framebuffers(fb_info->apertures, fb_info->fix.id, 1559 fb_is_primary_device(fb_info)); 1560 1561 num_registered_fb++; 1562 for (i = 0 ; i < FB_MAX; i++) 1563 if (!registered_fb[i]) 1564 break; 1565 fb_info->node = i; 1566 mutex_init(&fb_info->lock); 1567 mutex_init(&fb_info->mm_lock); 1568 1569 fb_info->dev = device_create(fb_class, fb_info->device, 1570 MKDEV(FB_MAJOR, i), NULL, "fb%d", i); 1571 if (IS_ERR(fb_info->dev)) { 1572 /* Not fatal */ 1573 printk(KERN_WARNING "Unable to create device for framebuffer %d; errno = %ld\n", i, PTR_ERR(fb_info->dev)); 1574 fb_info->dev = NULL; 1575 } else 1576 fb_init_device(fb_info); 1577 1578 if (fb_info->pixmap.addr == NULL) { 1579 fb_info->pixmap.addr = kmalloc(FBPIXMAPSIZE, GFP_KERNEL); 1580 if (fb_info->pixmap.addr) { 1581 fb_info->pixmap.size = FBPIXMAPSIZE; 1582 fb_info->pixmap.buf_align = 1; 1583 fb_info->pixmap.scan_align = 1; 1584 fb_info->pixmap.access_align = 32; 1585 fb_info->pixmap.flags = FB_PIXMAP_DEFAULT; 1586 } 1587 } 1588 fb_info->pixmap.offset = 0; 1589 1590 if (!fb_info->pixmap.blit_x) 1591 fb_info->pixmap.blit_x = ~(u32)0; 1592 1593 if (!fb_info->pixmap.blit_y) 1594 fb_info->pixmap.blit_y = ~(u32)0; 1595 1596 if (!fb_info->modelist.prev || !fb_info->modelist.next) 1597 INIT_LIST_HEAD(&fb_info->modelist); 1598 1599 fb_var_to_videomode(&mode, &fb_info->var); 1600 fb_add_videomode(&mode, &fb_info->modelist); 1601 registered_fb[i] = fb_info; 1602 1603 event.info = fb_info; 1604 if (!lock_fb_info(fb_info)) 1605 return -ENODEV; 1606 fb_notifier_call_chain(FB_EVENT_FB_REGISTERED, &event); 1607 unlock_fb_info(fb_info); 1608 return 0; 1609} 1610 1611 1612/** 1613 * unregister_framebuffer - releases a frame buffer device 1614 * @fb_info: frame buffer info structure 1615 * 1616 * Unregisters a frame buffer device @fb_info. 1617 * 1618 * Returns negative errno on error, or zero for success. 1619 * 1620 * This function will also notify the framebuffer console 1621 * to release the driver. 1622 * 1623 * This is meant to be called within a driver's module_exit() 1624 * function. If this is called outside module_exit(), ensure 1625 * that the driver implements fb_open() and fb_release() to 1626 * check that no processes are using the device. 1627 */ 1628 1629int 1630unregister_framebuffer(struct fb_info *fb_info) 1631{ 1632 struct fb_event event; 1633 int i, ret = 0; 1634 1635 i = fb_info->node; 1636 if (!registered_fb[i]) { 1637 ret = -EINVAL; 1638 goto done; 1639 } 1640 1641 1642 if (!lock_fb_info(fb_info)) 1643 return -ENODEV; 1644 event.info = fb_info; 1645 ret = fb_notifier_call_chain(FB_EVENT_FB_UNBIND, &event); 1646 unlock_fb_info(fb_info); 1647 1648 if (ret) { 1649 ret = -EINVAL; 1650 goto done; 1651 } 1652 1653 if (fb_info->pixmap.addr && 1654 (fb_info->pixmap.flags & FB_PIXMAP_DEFAULT)) 1655 kfree(fb_info->pixmap.addr); 1656 fb_destroy_modelist(&fb_info->modelist); 1657 registered_fb[i]=NULL; 1658 num_registered_fb--; 1659 fb_cleanup_device(fb_info); 1660 device_destroy(fb_class, MKDEV(FB_MAJOR, i)); 1661 event.info = fb_info; 1662 fb_notifier_call_chain(FB_EVENT_FB_UNREGISTERED, &event); 1663 1664 /* this may free fb info */ 1665 if (fb_info->fbops->fb_destroy) 1666 fb_info->fbops->fb_destroy(fb_info); 1667done: 1668 return ret; 1669} 1670 1671/** 1672 * fb_set_suspend - low level driver signals suspend 1673 * @info: framebuffer affected 1674 * @state: 0 = resuming, !=0 = suspending 1675 * 1676 * This is meant to be used by low level drivers to 1677 * signal suspend/resume to the core & clients. 1678 * It must be called with the console semaphore held 1679 */ 1680void fb_set_suspend(struct fb_info *info, int state) 1681{ 1682 struct fb_event event; 1683 1684 if (!lock_fb_info(info)) 1685 return; 1686 event.info = info; 1687 if (state) { 1688 fb_notifier_call_chain(FB_EVENT_SUSPEND, &event); 1689 info->state = FBINFO_STATE_SUSPENDED; 1690 } else { 1691 info->state = FBINFO_STATE_RUNNING; 1692 fb_notifier_call_chain(FB_EVENT_RESUME, &event); 1693 } 1694 unlock_fb_info(info); 1695} 1696 1697/** 1698 * fbmem_init - init frame buffer subsystem 1699 * 1700 * Initialize the frame buffer subsystem. 1701 * 1702 * NOTE: This function is _only_ to be called by drivers/char/mem.c. 1703 * 1704 */ 1705 1706static int __init 1707fbmem_init(void) 1708{ 1709 proc_create("fb", 0, NULL, &fb_proc_fops); 1710 1711 if (register_chrdev(FB_MAJOR,"fb",&fb_fops)) 1712 printk("unable to get major %d for fb devs\n", FB_MAJOR); 1713 1714 fb_class = class_create(THIS_MODULE, "graphics"); 1715 if (IS_ERR(fb_class)) { 1716 printk(KERN_WARNING "Unable to create fb class; errno = %ld\n", PTR_ERR(fb_class)); 1717 fb_class = NULL; 1718 } 1719 return 0; 1720} 1721 1722#ifdef MODULE 1723module_init(fbmem_init); 1724static void __exit 1725fbmem_exit(void) 1726{ 1727 remove_proc_entry("fb", NULL); 1728 class_destroy(fb_class); 1729 unregister_chrdev(FB_MAJOR, "fb"); 1730} 1731 1732module_exit(fbmem_exit); 1733MODULE_LICENSE("GPL"); 1734MODULE_DESCRIPTION("Framebuffer base"); 1735#else 1736subsys_initcall(fbmem_init); 1737#endif 1738 1739int fb_new_modelist(struct fb_info *info) 1740{ 1741 struct fb_event event; 1742 struct fb_var_screeninfo var = info->var; 1743 struct list_head *pos, *n; 1744 struct fb_modelist *modelist; 1745 struct fb_videomode *m, mode; 1746 int err = 1; 1747 1748 list_for_each_safe(pos, n, &info->modelist) { 1749 modelist = list_entry(pos, struct fb_modelist, list); 1750 m = &modelist->mode; 1751 fb_videomode_to_var(&var, m); 1752 var.activate = FB_ACTIVATE_TEST; 1753 err = fb_set_var(info, &var); 1754 fb_var_to_videomode(&mode, &var); 1755 if (err || !fb_mode_is_equal(m, &mode)) { 1756 list_del(pos); 1757 kfree(pos); 1758 } 1759 } 1760 1761 err = 1; 1762 1763 if (!list_empty(&info->modelist)) { 1764 if (!lock_fb_info(info)) 1765 return -ENODEV; 1766 event.info = info; 1767 err = fb_notifier_call_chain(FB_EVENT_NEW_MODELIST, &event); 1768 unlock_fb_info(info); 1769 } 1770 1771 return err; 1772} 1773 1774static char *video_options[FB_MAX] __read_mostly; 1775static int ofonly __read_mostly; 1776 1777/** 1778 * fb_get_options - get kernel boot parameters 1779 * @name: framebuffer name as it would appear in 1780 * the boot parameter line 1781 * (video=<name>:<options>) 1782 * @option: the option will be stored here 1783 * 1784 * NOTE: Needed to maintain backwards compatibility 1785 */ 1786int fb_get_options(char *name, char **option) 1787{ 1788 char *opt, *options = NULL; 1789 int retval = 0; 1790 int name_len = strlen(name), i; 1791 1792 if (name_len && ofonly && strncmp(name, "offb", 4)) 1793 retval = 1; 1794 1795 if (name_len && !retval) { 1796 for (i = 0; i < FB_MAX; i++) { 1797 if (video_options[i] == NULL) 1798 continue; 1799 if (!video_options[i][0]) 1800 continue; 1801 opt = video_options[i]; 1802 if (!strncmp(name, opt, name_len) && 1803 opt[name_len] == ':') 1804 options = opt + name_len + 1; 1805 } 1806 } 1807 if (options && !strncmp(options, "off", 3)) 1808 retval = 1; 1809 1810 if (option) 1811 *option = options; 1812 1813 return retval; 1814} 1815 1816#ifndef MODULE 1817/** 1818 * video_setup - process command line options 1819 * @options: string of options 1820 * 1821 * Process command line options for frame buffer subsystem. 1822 * 1823 * NOTE: This function is a __setup and __init function. 1824 * It only stores the options. Drivers have to call 1825 * fb_get_options() as necessary. 1826 * 1827 * Returns zero. 1828 * 1829 */ 1830static int __init video_setup(char *options) 1831{ 1832 int i, global = 0; 1833 1834 if (!options || !*options) 1835 global = 1; 1836 1837 if (!global && !strncmp(options, "ofonly", 6)) { 1838 ofonly = 1; 1839 global = 1; 1840 } 1841 1842 if (!global && !strchr(options, ':')) { 1843 fb_mode_option = options; 1844 global = 1; 1845 } 1846 1847 if (!global) { 1848 for (i = 0; i < FB_MAX; i++) { 1849 if (video_options[i] == NULL) { 1850 video_options[i] = options; 1851 break; 1852 } 1853 1854 } 1855 } 1856 1857 return 1; 1858} 1859__setup("video=", video_setup); 1860#endif 1861 1862 /* 1863 * Visible symbols for modules 1864 */ 1865 1866EXPORT_SYMBOL(register_framebuffer); 1867EXPORT_SYMBOL(unregister_framebuffer); 1868EXPORT_SYMBOL(num_registered_fb); 1869EXPORT_SYMBOL(registered_fb); 1870EXPORT_SYMBOL(fb_show_logo); 1871EXPORT_SYMBOL(fb_set_var); 1872EXPORT_SYMBOL(fb_blank); 1873EXPORT_SYMBOL(fb_pan_display); 1874EXPORT_SYMBOL(fb_get_buffer_offset); 1875EXPORT_SYMBOL(fb_set_suspend); 1876EXPORT_SYMBOL(fb_get_options); 1877 1878MODULE_LICENSE("GPL"); 1879