git.oblomov.eu Git - linux-2.6/blob - drivers/video/fbmem.c

   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/config.h>
  15 #include <linux/module.h>
  16
  17 #include <linux/types.h>
  18 #include <linux/errno.h>
  19 #include <linux/sched.h>
  20 #include <linux/smp_lock.h>
  21 #include <linux/kernel.h>
  22 #include <linux/major.h>
  23 #include <linux/slab.h>
  24 #include <linux/mm.h>
  25 #include <linux/mman.h>
  26 #include <linux/tty.h>
  27 #include <linux/init.h>
  28 #include <linux/linux_logo.h>
  29 #include <linux/proc_fs.h>
  30 #include <linux/console.h>
  31 #ifdef CONFIG_KMOD
  32 #include <linux/kmod.h>
  33 #endif
  34 #include <linux/devfs_fs_kernel.h>
  35 #include <linux/err.h>
  36 #include <linux/kernel.h>
  37 #include <linux/device.h>
  38 #include <linux/efi.h>
  39
  40 #if defined(__mc68000__) || defined(CONFIG_APUS)
  41 #include <asm/setup.h>
  42 #endif
  43
  44 #include <asm/io.h>
  45 #include <asm/uaccess.h>
  46 #include <asm/page.h>
  47 #include <asm/pgtable.h>
  48
  49 #include <linux/fb.h>
  50
  51     /*
  52      *  Frame buffer device initialization and setup routines
  53      */
  54
  55 #define FBPIXMAPSIZE    (1024 * 8)
  56
  57 static struct notifier_block *fb_notifier_list;
  58 struct fb_info *registered_fb[FB_MAX];
  59 int num_registered_fb;
  60
  61 /*
  62  * Helpers
  63  */
  64
  65 int fb_get_color_depth(struct fb_var_screeninfo *var,
  66                        struct fb_fix_screeninfo *fix)
  67 {
  68         int depth = 0;
  69
  70         if (fix->visual == FB_VISUAL_MONO01 ||
  71             fix->visual == FB_VISUAL_MONO10)
  72                 depth = 1;
  73         else {
  74                 if (var->green.length == var->blue.length &&
  75                     var->green.length == var->red.length &&
  76                     var->green.offset == var->blue.offset &&
  77                     var->green.offset == var->red.offset)
  78                         depth = var->green.length;
  79                 else
  80                         depth = var->green.length + var->red.length +
  81                                 var->blue.length;
  82         }
  83
  84         return depth;
  85 }
  86 EXPORT_SYMBOL(fb_get_color_depth);
  87
  88 /*
  89  * Data padding functions.
  90  */
  91 void fb_pad_aligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 s_pitch, u32 height)
  92 {
  93         __fb_pad_aligned_buffer(dst, d_pitch, src, s_pitch, height);
  94 }
  95 EXPORT_SYMBOL(fb_pad_aligned_buffer);
  96
  97 void fb_pad_unaligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 idx, u32 height,
  98                                 u32 shift_high, u32 shift_low, u32 mod)
  99 {
 100         u8 mask = (u8) (0xfff << shift_high), tmp;
 101         int i, j;
 102
 103         for (i = height; i--; ) {
 104                 for (j = 0; j < idx; j++) {
 105                         tmp = dst[j];
 106                         tmp &= mask;
 107                         tmp |= *src >> shift_low;
 108                         dst[j] = tmp;
 109                         tmp = *src << shift_high;
 110                         dst[j+1] = tmp;
 111                         src++;
 112                 }
 113                 tmp = dst[idx];
 114                 tmp &= mask;
 115                 tmp |= *src >> shift_low;
 116                 dst[idx] = tmp;
 117                 if (shift_high < mod) {
 118                         tmp = *src << shift_high;
 119                         dst[idx+1] = tmp;
 120                 }
 121                 src++;
 122                 dst += d_pitch;
 123         }
 124 }
 125 EXPORT_SYMBOL(fb_pad_unaligned_buffer);
 126
 127 /*
 128  * we need to lock this section since fb_cursor
 129  * may use fb_imageblit()
 130  */
 131 char* fb_get_buffer_offset(struct fb_info *info, struct fb_pixmap *buf, u32 size)
 132 {
 133         u32 align = buf->buf_align - 1, offset;
 134         char *addr = buf->addr;
 135
 136         /* If IO mapped, we need to sync before access, no sharing of
 137          * the pixmap is done
 138          */
 139         if (buf->flags & FB_PIXMAP_IO) {
 140                 if (info->fbops->fb_sync && (buf->flags & FB_PIXMAP_SYNC))
 141                         info->fbops->fb_sync(info);
 142                 return addr;
 143         }
 144
 145         /* See if we fit in the remaining pixmap space */
 146         offset = buf->offset + align;
 147         offset &= ~align;
 148         if (offset + size > buf->size) {
 149                 /* We do not fit. In order to be able to re-use the buffer,
 150                  * we must ensure no asynchronous DMA'ing or whatever operation
 151                  * is in progress, we sync for that.
 152                  */
 153                 if (info->fbops->fb_sync && (buf->flags & FB_PIXMAP_SYNC))
 154                         info->fbops->fb_sync(info);
 155                 offset = 0;
 156         }
 157         buf->offset = offset + size;
 158         addr += offset;
 159
 160         return addr;
 161 }
 162
 163 #ifdef CONFIG_LOGO
 164 #include <linux/linux_logo.h>
 165
 166 static inline unsigned safe_shift(unsigned d, int n)
 167 {
 168         return n < 0 ? d >> -n : d << n;
 169 }
 170
 171 static void fb_set_logocmap(struct fb_info *info,
 172                                    const struct linux_logo *logo)
 173 {
 174         struct fb_cmap palette_cmap;
 175         u16 palette_green[16];
 176         u16 palette_blue[16];
 177         u16 palette_red[16];
 178         int i, j, n;
 179         const unsigned char *clut = logo->clut;
 180
 181         palette_cmap.start = 0;
 182         palette_cmap.len = 16;
 183         palette_cmap.red = palette_red;
 184         palette_cmap.green = palette_green;
 185         palette_cmap.blue = palette_blue;
 186         palette_cmap.transp = NULL;
 187
 188         for (i = 0; i < logo->clutsize; i += n) {
 189                 n = logo->clutsize - i;
 190                 /* palette_cmap provides space for only 16 colors at once */
 191                 if (n > 16)
 192                         n = 16;
 193                 palette_cmap.start = 32 + i;
 194                 palette_cmap.len = n;
 195                 for (j = 0; j < n; ++j) {
 196                         palette_cmap.red[j] = clut[0] << 8 | clut[0];
 197                         palette_cmap.green[j] = clut[1] << 8 | clut[1];
 198                         palette_cmap.blue[j] = clut[2] << 8 | clut[2];
 199                         clut += 3;
 200                 }
 201                 fb_set_cmap(&palette_cmap, info);
 202         }
 203 }
 204
 205 static void  fb_set_logo_truepalette(struct fb_info *info,
 206                                             const struct linux_logo *logo,
 207                                             u32 *palette)
 208 {
 209         unsigned char mask[9] = { 0,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff };
 210         unsigned char redmask, greenmask, bluemask;
 211         int redshift, greenshift, blueshift;
 212         int i;
 213         const unsigned char *clut = logo->clut;
 214
 215         /*
 216          * We have to create a temporary palette since console palette is only
 217          * 16 colors long.
 218          */
 219         /* Bug: Doesn't obey msb_right ... (who needs that?) */
 220         redmask   = mask[info->var.red.length   < 8 ? info->var.red.length   : 8];
 221         greenmask = mask[info->var.green.length < 8 ? info->var.green.length : 8];
 222         bluemask  = mask[info->var.blue.length  < 8 ? info->var.blue.length  : 8];
 223         redshift   = info->var.red.offset   - (8 - info->var.red.length);
 224         greenshift = info->var.green.offset - (8 - info->var.green.length);
 225         blueshift  = info->var.blue.offset  - (8 - info->var.blue.length);
 226
 227         for ( i = 0; i < logo->clutsize; i++) {
 228                 palette[i+32] = (safe_shift((clut[0] & redmask), redshift) |
 229                                  safe_shift((clut[1] & greenmask), greenshift) |
 230                                  safe_shift((clut[2] & bluemask), blueshift));
 231                 clut += 3;
 232         }
 233 }
 234
 235 static void fb_set_logo_directpalette(struct fb_info *info,
 236                                              const struct linux_logo *logo,
 237                                              u32 *palette)
 238 {
 239         int redshift, greenshift, blueshift;
 240         int i;
 241
 242         redshift = info->var.red.offset;
 243         greenshift = info->var.green.offset;
 244         blueshift = info->var.blue.offset;
 245
 246         for (i = 32; i < logo->clutsize; i++)
 247                 palette[i] = i << redshift | i << greenshift | i << blueshift;
 248 }
 249
 250 static void fb_set_logo(struct fb_info *info,
 251                                const struct linux_logo *logo, u8 *dst,
 252                                int depth)
 253 {
 254         int i, j, k;
 255         const u8 *src = logo->data;
 256         u8 xor = (info->fix.visual == FB_VISUAL_MONO01) ? 0xff : 0;
 257         u8 fg = 1, d;
 258
 259         if (fb_get_color_depth(&info->var, &info->fix) == 3)
 260                 fg = 7;
 261
 262         if (info->fix.visual == FB_VISUAL_MONO01 ||
 263             info->fix.visual == FB_VISUAL_MONO10)
 264                 fg = ~((u8) (0xfff << info->var.green.length));
 265
 266         switch (depth) {
 267         case 4:
 268                 for (i = 0; i < logo->height; i++)
 269                         for (j = 0; j < logo->width; src++) {
 270                                 *dst++ = *src >> 4;
 271                                 j++;
 272                                 if (j < logo->width) {
 273                                         *dst++ = *src & 0x0f;
 274                                         j++;
 275                                 }
 276                         }
 277                 break;
 278         case 1:
 279                 for (i = 0; i < logo->height; i++) {
 280                         for (j = 0; j < logo->width; src++) {
 281                                 d = *src ^ xor;
 282                                 for (k = 7; k >= 0; k--) {
 283                                         *dst++ = ((d >> k) & 1) ? fg : 0;
 284                                         j++;
 285                                 }
 286                         }
 287                 }
 288                 break;
 289         }
 290 }
 291
 292 /*
 293  * Three (3) kinds of logo maps exist.  linux_logo_clut224 (>16 colors),
 294  * linux_logo_vga16 (16 colors) and linux_logo_mono (2 colors).  Depending on
 295  * the visual format and color depth of the framebuffer, the DAC, the
 296  * pseudo_palette, and the logo data will be adjusted accordingly.
 297  *
 298  * Case 1 - linux_logo_clut224:
 299  * Color exceeds the number of console colors (16), thus we set the hardware DAC
 300  * using fb_set_cmap() appropriately.  The "needs_cmapreset"  flag will be set.
 301  *
 302  * For visuals that require color info from the pseudo_palette, we also construct
 303  * one for temporary use. The "needs_directpalette" or "needs_truepalette" flags
 304  * will be set.
 305  *
 306  * Case 2 - linux_logo_vga16:
 307  * The number of colors just matches the console colors, thus there is no need
 308  * to set the DAC or the pseudo_palette.  However, the bitmap is packed, ie,
 309  * each byte contains color information for two pixels (upper and lower nibble).
 310  * To be consistent with fb_imageblit() usage, we therefore separate the two
 311  * nibbles into separate bytes. The "depth" flag will be set to 4.
 312  *
 313  * Case 3 - linux_logo_mono:
 314  * This is similar with Case 2.  Each byte contains information for 8 pixels.
 315  * We isolate each bit and expand each into a byte. The "depth" flag will
 316  * be set to 1.
 317  */
 318 static struct logo_data {
 319         int depth;
 320         int needs_directpalette;
 321         int needs_truepalette;
 322         int needs_cmapreset;
 323         const struct linux_logo *logo;
 324 } fb_logo;
 325
 326 int fb_prepare_logo(struct fb_info *info)
 327 {
 328         int depth = fb_get_color_depth(&info->var, &info->fix);
 329
 330         memset(&fb_logo, 0, sizeof(struct logo_data));
 331
 332         if (info->flags & FBINFO_MISC_TILEBLITTING)
 333                 return 0;
 334
 335         if (info->fix.visual == FB_VISUAL_DIRECTCOLOR) {
 336                 depth = info->var.blue.length;
 337                 if (info->var.red.length < depth)
 338                         depth = info->var.red.length;
 339                 if (info->var.green.length < depth)
 340                         depth = info->var.green.length;
 341         }
 342
 343         if (depth >= 8) {
 344                 switch (info->fix.visual) {
 345                 case FB_VISUAL_TRUECOLOR:
 346                         fb_logo.needs_truepalette = 1;
 347                         break;
 348                 case FB_VISUAL_DIRECTCOLOR:
 349                         fb_logo.needs_directpalette = 1;
 350                         fb_logo.needs_cmapreset = 1;
 351                         break;
 352                 case FB_VISUAL_PSEUDOCOLOR:
 353                         fb_logo.needs_cmapreset = 1;
 354                         break;
 355                 }
 356         }
 357
 358         /* Return if no suitable logo was found */
 359         fb_logo.logo = fb_find_logo(depth);
 360
 361         if (!fb_logo.logo || fb_logo.logo->height > info->var.yres) {
 362                 fb_logo.logo = NULL;
 363                 return 0;
 364         }
 365         /* What depth we asked for might be different from what we get */
 366         if (fb_logo.logo->type == LINUX_LOGO_CLUT224)
 367                 fb_logo.depth = 8;
 368         else if (fb_logo.logo->type == LINUX_LOGO_VGA16)
 369                 fb_logo.depth = 4;
 370         else
 371                 fb_logo.depth = 1;
 372         return fb_logo.logo->height;
 373 }
 374
 375 int fb_show_logo(struct fb_info *info)
 376 {
 377         u32 *palette = NULL, *saved_pseudo_palette = NULL;
 378         unsigned char *logo_new = NULL;
 379         struct fb_image image;
 380         int x;
 381
 382         /* Return if the frame buffer is not mapped or suspended */
 383         if (fb_logo.logo == NULL || info->state != FBINFO_STATE_RUNNING)
 384                 return 0;
 385
 386         image.depth = 8;
 387         image.data = fb_logo.logo->data;
 388
 389         if (fb_logo.needs_cmapreset)
 390                 fb_set_logocmap(info, fb_logo.logo);
 391
 392         if (fb_logo.needs_truepalette ||
 393             fb_logo.needs_directpalette) {
 394                 palette = kmalloc(256 * 4, GFP_KERNEL);
 395                 if (palette == NULL)
 396                         return 0;
 397
 398                 if (fb_logo.needs_truepalette)
 399                         fb_set_logo_truepalette(info, fb_logo.logo, palette);
 400                 else
 401                         fb_set_logo_directpalette(info, fb_logo.logo, palette);
 402
 403                 saved_pseudo_palette = info->pseudo_palette;
 404                 info->pseudo_palette = palette;
 405         }
 406
 407         if (fb_logo.depth <= 4) {
 408                 logo_new = kmalloc(fb_logo.logo->width * fb_logo.logo->height,
 409                                    GFP_KERNEL);
 410                 if (logo_new == NULL) {
 411                         kfree(palette);
 412                         if (saved_pseudo_palette)
 413                                 info->pseudo_palette = saved_pseudo_palette;
 414                         return 0;
 415                 }
 416                 image.data = logo_new;
 417                 fb_set_logo(info, fb_logo.logo, logo_new, fb_logo.depth);
 418         }
 419
 420         image.width = fb_logo.logo->width;
 421         image.height = fb_logo.logo->height;
 422         image.dy = 0;
 423
 424         for (x = 0; x < num_online_cpus() * (fb_logo.logo->width + 8) &&
 425              x <= info->var.xres-fb_logo.logo->width; x += (fb_logo.logo->width + 8)) {
 426                 image.dx = x;
 427                 info->fbops->fb_imageblit(info, &image);
 428         }
 429
 430         kfree(palette);
 431         if (saved_pseudo_palette != NULL)
 432                 info->pseudo_palette = saved_pseudo_palette;
 433         kfree(logo_new);
 434         return fb_logo.logo->height;
 435 }
 436 #else
 437 int fb_prepare_logo(struct fb_info *info) { return 0; }
 438 int fb_show_logo(struct fb_info *info) { return 0; }
 439 #endif /* CONFIG_LOGO */
 440
 441 static int fbmem_read_proc(char *buf, char **start, off_t offset,
 442                            int len, int *eof, void *private)
 443 {
 444         struct fb_info **fi;
 445         int clen;
 446
 447         clen = 0;
 448         for (fi = registered_fb; fi < &registered_fb[FB_MAX] && len < 4000; fi++)
 449                 if (*fi)
 450                         clen += sprintf(buf + clen, "%d %s\n",
 451                                         (*fi)->node,
 452                                         (*fi)->fix.id);
 453         *start = buf + offset;
 454         if (clen > offset)
 455                 clen -= offset;
 456         else
 457                 clen = 0;
 458         return clen < len ? clen : len;
 459 }
 460
 461 static ssize_t
 462 fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 463 {
 464         unsigned long p = *ppos;
 465         struct inode *inode = file->f_dentry->d_inode;
 466         int fbidx = iminor(inode);
 467         struct fb_info *info = registered_fb[fbidx];
 468         u32 *buffer, *dst;
 469         u32 __iomem *src;
 470         int c, i, cnt = 0, err = 0;
 471         unsigned long total_size;
 472
 473         if (!info || ! info->screen_base)
 474                 return -ENODEV;
 475
 476         if (info->state != FBINFO_STATE_RUNNING)
 477                 return -EPERM;
 478
 479         if (info->fbops->fb_read)
 480                 return info->fbops->fb_read(file, buf, count, ppos);
 481
 482         total_size = info->screen_size;
 483         if (total_size == 0)
 484                 total_size = info->fix.smem_len;
 485
 486         if (p >= total_size)
 487             return 0;
 488         if (count >= total_size)
 489             count = total_size;
 490         if (count + p > total_size)
 491                 count = total_size - p;
 492
 493         cnt = 0;
 494         buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,
 495                          GFP_KERNEL);
 496         if (!buffer)
 497                 return -ENOMEM;
 498
 499         src = (u32 __iomem *) (info->screen_base + p);
 500
 501         if (info->fbops->fb_sync)
 502                 info->fbops->fb_sync(info);
 503
 504         while (count) {
 505                 c  = (count > PAGE_SIZE) ? PAGE_SIZE : count;
 506                 dst = buffer;
 507                 for (i = c >> 2; i--; )
 508                         *dst++ = fb_readl(src++);
 509                 if (c & 3) {
 510                         u8 *dst8 = (u8 *) dst;
 511                         u8 __iomem *src8 = (u8 __iomem *) src;
 512
 513                         for (i = c & 3; i--;)
 514                                 *dst8++ = fb_readb(src8++);
 515
 516                         src = (u32 __iomem *) src8;
 517                 }
 518
 519                 if (copy_to_user(buf, buffer, c)) {
 520                         err = -EFAULT;
 521                         break;
 522                 }
 523                 *ppos += c;
 524                 buf += c;
 525                 cnt += c;
 526                 count -= c;
 527         }
 528
 529         kfree(buffer);
 530         return (err) ? err : cnt;
 531 }
 532
 533 static ssize_t
 534 fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 535 {
 536         unsigned long p = *ppos;
 537         struct inode *inode = file->f_dentry->d_inode;
 538         int fbidx = iminor(inode);
 539         struct fb_info *info = registered_fb[fbidx];
 540         u32 *buffer, *src;
 541         u32 __iomem *dst;
 542         int c, i, cnt = 0, err;
 543         unsigned long total_size;
 544
 545         if (!info || !info->screen_base)
 546                 return -ENODEV;
 547
 548         if (info->state != FBINFO_STATE_RUNNING)
 549                 return -EPERM;
 550
 551         if (info->fbops->fb_write)
 552                 return info->fbops->fb_write(file, buf, count, ppos);
 553
 554         total_size = info->screen_size;
 555         if (total_size == 0)
 556                 total_size = info->fix.smem_len;
 557
 558         if (p > total_size)
 559             return -ENOSPC;
 560         if (count >= total_size)
 561             count = total_size;
 562         err = 0;
 563         if (count + p > total_size) {
 564             count = total_size - p;
 565             err = -ENOSPC;
 566         }
 567         cnt = 0;
 568         buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,
 569                          GFP_KERNEL);
 570         if (!buffer)
 571                 return -ENOMEM;
 572
 573         dst = (u32 __iomem *) (info->screen_base + p);
 574
 575         if (info->fbops->fb_sync)
 576                 info->fbops->fb_sync(info);
 577
 578         while (count) {
 579                 c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
 580                 src = buffer;
 581                 if (copy_from_user(src, buf, c)) {
 582                         err = -EFAULT;
 583                         break;
 584                 }
 585                 for (i = c >> 2; i--; )
 586                         fb_writel(*src++, dst++);
 587                 if (c & 3) {
 588                         u8 *src8 = (u8 *) src;
 589                         u8 __iomem *dst8 = (u8 __iomem *) dst;
 590
 591                         for (i = c & 3; i--; )
 592                                 fb_writeb(*src8++, dst8++);
 593
 594                         dst = (u32 __iomem *) dst8;
 595                 }
 596                 *ppos += c;
 597                 buf += c;
 598                 cnt += c;
 599                 count -= c;
 600         }
 601         kfree(buffer);
 602
 603         return (err) ? err : cnt;
 604 }
 605
 606 #ifdef CONFIG_KMOD
 607 static void try_to_load(int fb)
 608 {
 609         request_module("fb%d", fb);
 610 }
 611 #endif /* CONFIG_KMOD */
 612
 613 int
 614 fb_pan_display(struct fb_info *info, struct fb_var_screeninfo *var)
 615 {
 616         int xoffset = var->xoffset;
 617         int yoffset = var->yoffset;
 618         int err;
 619
 620         if (xoffset < 0 || yoffset < 0 || !info->fbops->fb_pan_display ||
 621             xoffset + info->var.xres > info->var.xres_virtual ||
 622             yoffset + info->var.yres > info->var.yres_virtual)
 623                 return -EINVAL;
 624         if ((err = info->fbops->fb_pan_display(var, info)))
 625                 return err;
 626         info->var.xoffset = var->xoffset;
 627         info->var.yoffset = var->yoffset;
 628         if (var->vmode & FB_VMODE_YWRAP)
 629                 info->var.vmode |= FB_VMODE_YWRAP;
 630         else
 631                 info->var.vmode &= ~FB_VMODE_YWRAP;
 632         return 0;
 633 }
 634
 635 int
 636 fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var)
 637 {
 638         int err, flags = info->flags;
 639
 640         if (var->activate & FB_ACTIVATE_INV_MODE) {
 641                 struct fb_videomode mode1, mode2;
 642                 int ret = 0;
 643
 644                 fb_var_to_videomode(&mode1, var);
 645                 fb_var_to_videomode(&mode2, &info->var);
 646                 /* make sure we don't delete the videomode of current var */
 647                 ret = fb_mode_is_equal(&mode1, &mode2);
 648
 649                 if (!ret) {
 650                     struct fb_event event;
 651
 652                     event.info = info;
 653                     event.data = &mode1;
 654                     ret = notifier_call_chain(&fb_notifier_list,
 655                                               FB_EVENT_MODE_DELETE, &event);
 656                 }
 657
 658                 if (!ret)
 659                     fb_delete_videomode(&mode1, &info->modelist);
 660
 661                 return ret;
 662         }
 663
 664         if ((var->activate & FB_ACTIVATE_FORCE) ||
 665             memcmp(&info->var, var, sizeof(struct fb_var_screeninfo))) {
 666                 if (!info->fbops->fb_check_var) {
 667                         *var = info->var;
 668                         return 0;
 669                 }
 670
 671                 if ((err = info->fbops->fb_check_var(var, info)))
 672                         return err;
 673
 674                 if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) {
 675                         struct fb_videomode mode;
 676                         int err = 0;
 677
 678                         info->var = *var;
 679                         if (info->fbops->fb_set_par)
 680                                 info->fbops->fb_set_par(info);
 681
 682                         fb_pan_display(info, &info->var);
 683
 684                         fb_set_cmap(&info->cmap, info);
 685
 686                         fb_var_to_videomode(&mode, &info->var);
 687
 688                         if (info->modelist.prev && info->modelist.next &&
 689                             !list_empty(&info->modelist))
 690                                 err = fb_add_videomode(&mode, &info->modelist);
 691
 692                         if (!err && (flags & FBINFO_MISC_USEREVENT)) {
 693                                 struct fb_event event;
 694                                 int evnt = (var->activate & FB_ACTIVATE_ALL) ?
 695                                         FB_EVENT_MODE_CHANGE_ALL :
 696                                         FB_EVENT_MODE_CHANGE;
 697
 698                                 info->flags &= ~FBINFO_MISC_USEREVENT;
 699                                 event.info = info;
 700                                 notifier_call_chain(&fb_notifier_list, evnt,
 701                                                     &event);
 702                         }
 703                 }
 704         }
 705         return 0;
 706 }
 707
 708 int
 709 fb_blank(struct fb_info *info, int blank)
 710 {
 711         int ret = -EINVAL;
 712
 713         if (blank > FB_BLANK_POWERDOWN)
 714                 blank = FB_BLANK_POWERDOWN;
 715
 716         if (info->fbops->fb_blank)
 717                 ret = info->fbops->fb_blank(blank, info);
 718
 719         if (!ret) {
 720                 struct fb_event event;
 721
 722                 event.info = info;
 723                 event.data = &blank;
 724                 notifier_call_chain(&fb_notifier_list, FB_EVENT_BLANK, &event);
 725         }
 726
 727         return ret;
 728 }
 729
 730 static int
 731 fb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 732          unsigned long arg)
 733 {
 734         int fbidx = iminor(inode);
 735         struct fb_info *info = registered_fb[fbidx];
 736         struct fb_ops *fb = info->fbops;
 737         struct fb_var_screeninfo var;
 738         struct fb_fix_screeninfo fix;
 739         struct fb_con2fbmap con2fb;
 740         struct fb_cmap_user cmap;
 741         struct fb_event event;
 742         void __user *argp = (void __user *)arg;
 743         int i;
 744
 745         if (!fb)
 746                 return -ENODEV;
 747         switch (cmd) {
 748         case FBIOGET_VSCREENINFO:
 749                 return copy_to_user(argp, &info->var,
 750                                     sizeof(var)) ? -EFAULT : 0;
 751         case FBIOPUT_VSCREENINFO:
 752                 if (copy_from_user(&var, argp, sizeof(var)))
 753                         return -EFAULT;
 754                 acquire_console_sem();
 755                 info->flags |= FBINFO_MISC_USEREVENT;
 756                 i = fb_set_var(info, &var);
 757                 info->flags &= ~FBINFO_MISC_USEREVENT;
 758                 release_console_sem();
 759                 if (i) return i;
 760                 if (copy_to_user(argp, &var, sizeof(var)))
 761                         return -EFAULT;
 762                 return 0;
 763         case FBIOGET_FSCREENINFO:
 764                 return copy_to_user(argp, &info->fix,
 765                                     sizeof(fix)) ? -EFAULT : 0;
 766         case FBIOPUTCMAP:
 767                 if (copy_from_user(&cmap, argp, sizeof(cmap)))
 768                         return -EFAULT;
 769                 return (fb_set_user_cmap(&cmap, info));
 770         case FBIOGETCMAP:
 771                 if (copy_from_user(&cmap, argp, sizeof(cmap)))
 772                         return -EFAULT;
 773                 return fb_cmap_to_user(&info->cmap, &cmap);
 774         case FBIOPAN_DISPLAY:
 775                 if (copy_from_user(&var, argp, sizeof(var)))
 776                         return -EFAULT;
 777                 acquire_console_sem();
 778                 i = fb_pan_display(info, &var);
 779                 release_console_sem();
 780                 if (i)
 781                         return i;
 782                 if (copy_to_user(argp, &var, sizeof(var)))
 783                         return -EFAULT;
 784                 return 0;
 785         case FBIO_CURSOR:
 786                 return -EINVAL;
 787         case FBIOGET_CON2FBMAP:
 788                 if (copy_from_user(&con2fb, argp, sizeof(con2fb)))
 789                         return -EFAULT;
 790                 if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES)
 791                     return -EINVAL;
 792                 con2fb.framebuffer = -1;
 793                 event.info = info;
 794                 event.data = &con2fb;
 795                 notifier_call_chain(&fb_notifier_list,
 796                                     FB_EVENT_GET_CONSOLE_MAP, &event);
 797                 return copy_to_user(argp, &con2fb,
 798                                     sizeof(con2fb)) ? -EFAULT : 0;
 799         case FBIOPUT_CON2FBMAP:
 800                 if (copy_from_user(&con2fb, argp, sizeof(con2fb)))
 801                         return - EFAULT;
 802                 if (con2fb.console < 0 || con2fb.console > MAX_NR_CONSOLES)
 803                     return -EINVAL;
 804                 if (con2fb.framebuffer < 0 || con2fb.framebuffer >= FB_MAX)
 805                     return -EINVAL;
 806 #ifdef CONFIG_KMOD
 807                 if (!registered_fb[con2fb.framebuffer])
 808                     try_to_load(con2fb.framebuffer);
 809 #endif /* CONFIG_KMOD */
 810                 if (!registered_fb[con2fb.framebuffer])
 811                     return -EINVAL;
 812                 event.info = info;
 813                 event.data = &con2fb;
 814                 return notifier_call_chain(&fb_notifier_list,
 815                                            FB_EVENT_SET_CONSOLE_MAP,
 816                                            &event);
 817         case FBIOBLANK:
 818                 acquire_console_sem();
 819                 info->flags |= FBINFO_MISC_USEREVENT;
 820                 i = fb_blank(info, arg);
 821                 info->flags &= ~FBINFO_MISC_USEREVENT;
 822                 release_console_sem();
 823                 return i;
 824         default:
 825                 if (fb->fb_ioctl == NULL)
 826                         return -EINVAL;
 827                 return fb->fb_ioctl(inode, file, cmd, arg, info);
 828         }
 829 }
 830
 831 #ifdef CONFIG_COMPAT
 832 static long
 833 fb_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 834 {
 835         int fbidx = iminor(file->f_dentry->d_inode);
 836         struct fb_info *info = registered_fb[fbidx];
 837         struct fb_ops *fb = info->fbops;
 838         long ret;
 839
 840         if (fb->fb_compat_ioctl == NULL)
 841                 return -ENOIOCTLCMD;
 842         lock_kernel();
 843         ret = fb->fb_compat_ioctl(file, cmd, arg, info);
 844         unlock_kernel();
 845         return ret;
 846 }
 847 #endif
 848
 849 static int
 850 fb_mmap(struct file *file, struct vm_area_struct * vma)
 851 {
 852         int fbidx = iminor(file->f_dentry->d_inode);
 853         struct fb_info *info = registered_fb[fbidx];
 854         struct fb_ops *fb = info->fbops;
 855         unsigned long off;
 856 #if !defined(__sparc__) || defined(__sparc_v9__)
 857         unsigned long start;
 858         u32 len;
 859 #endif
 860
 861         if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
 862                 return -EINVAL;
 863         off = vma->vm_pgoff << PAGE_SHIFT;
 864         if (!fb)
 865                 return -ENODEV;
 866         if (fb->fb_mmap) {
 867                 int res;
 868                 lock_kernel();
 869                 res = fb->fb_mmap(info, file, vma);
 870                 unlock_kernel();
 871                 return res;
 872         }
 873
 874 #if defined(__sparc__) && !defined(__sparc_v9__)
 875         /* Should never get here, all fb drivers should have their own
 876            mmap routines */
 877         return -EINVAL;
 878 #else
 879         /* !sparc32... */
 880         lock_kernel();
 881
 882         /* frame buffer memory */
 883         start = info->fix.smem_start;
 884         len = PAGE_ALIGN((start & ~PAGE_MASK) + info->fix.smem_len);
 885         if (off >= len) {
 886                 /* memory mapped io */
 887                 off -= len;
 888                 if (info->var.accel_flags) {
 889                         unlock_kernel();
 890                         return -EINVAL;
 891                 }
 892                 start = info->fix.mmio_start;
 893                 len = PAGE_ALIGN((start & ~PAGE_MASK) + info->fix.mmio_len);
 894         }
 895         unlock_kernel();
 896         start &= PAGE_MASK;
 897         if ((vma->vm_end - vma->vm_start + off) > len)
 898                 return -EINVAL;
 899         off += start;
 900         vma->vm_pgoff = off >> PAGE_SHIFT;
 901         /* This is an IO map - tell maydump to skip this VMA */
 902         vma->vm_flags |= VM_IO | VM_RESERVED;
 903 #if defined(__sparc_v9__)
 904         if (io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
 905                                 vma->vm_end - vma->vm_start, vma->vm_page_prot))
 906                 return -EAGAIN;
 907 #else
 908 #if defined(__mc68000__)
 909 #if defined(CONFIG_SUN3)
 910         pgprot_val(vma->vm_page_prot) |= SUN3_PAGE_NOCACHE;
 911 #elif defined(CONFIG_MMU)
 912         if (CPU_IS_020_OR_030)
 913                 pgprot_val(vma->vm_page_prot) |= _PAGE_NOCACHE030;
 914         if (CPU_IS_040_OR_060) {
 915                 pgprot_val(vma->vm_page_prot) &= _CACHEMASK040;
 916                 /* Use no-cache mode, serialized */
 917                 pgprot_val(vma->vm_page_prot) |= _PAGE_NOCACHE_S;
 918         }
 919 #endif
 920 #elif defined(__powerpc__)
 921         vma->vm_page_prot = phys_mem_access_prot(file, off >> PAGE_SHIFT,
 922                                                  vma->vm_end - vma->vm_start,
 923                                                  vma->vm_page_prot);
 924 #elif defined(__alpha__)
 925         /* Caching is off in the I/O space quadrant by design.  */
 926 #elif defined(__i386__) || defined(__x86_64__)
 927         if (boot_cpu_data.x86 > 3)
 928                 pgprot_val(vma->vm_page_prot) |= _PAGE_PCD;
 929 #elif defined(__mips__)
 930         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 931 #elif defined(__hppa__)
 932         pgprot_val(vma->vm_page_prot) |= _PAGE_NO_CACHE;
 933 #elif defined(__arm__) || defined(__sh__) || defined(__m32r__)
 934         vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
 935 #elif defined(__ia64__)
 936         if (efi_range_is_wc(vma->vm_start, vma->vm_end - vma->vm_start))
 937                 vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
 938         else
 939                 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 940 #else
 941 #warning What do we have to do here??
 942 #endif
 943         if (io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
 944                              vma->vm_end - vma->vm_start, vma->vm_page_prot))
 945                 return -EAGAIN;
 946 #endif /* !__sparc_v9__ */
 947         return 0;
 948 #endif /* !sparc32 */
 949 }
 950
 951 static int
 952 fb_open(struct inode *inode, struct file *file)
 953 {
 954         int fbidx = iminor(inode);
 955         struct fb_info *info;
 956         int res = 0;
 957
 958         if (fbidx >= FB_MAX)
 959                 return -ENODEV;
 960 #ifdef CONFIG_KMOD
 961         if (!(info = registered_fb[fbidx]))
 962                 try_to_load(fbidx);
 963 #endif /* CONFIG_KMOD */
 964         if (!(info = registered_fb[fbidx]))
 965                 return -ENODEV;
 966         if (!try_module_get(info->fbops->owner))
 967                 return -ENODEV;
 968         if (info->fbops->fb_open) {
 969                 res = info->fbops->fb_open(info,1);
 970                 if (res)
 971                         module_put(info->fbops->owner);
 972         }
 973         return res;
 974 }
 975
 976 static int
 977 fb_release(struct inode *inode, struct file *file)
 978 {
 979         int fbidx = iminor(inode);
 980         struct fb_info *info;
 981
 982         lock_kernel();
 983         info = registered_fb[fbidx];
 984         if (info->fbops->fb_release)
 985                 info->fbops->fb_release(info,1);
 986         module_put(info->fbops->owner);
 987         unlock_kernel();
 988         return 0;
 989 }
 990
 991 static struct file_operations fb_fops = {
 992         .owner =        THIS_MODULE,
 993         .read =         fb_read,
 994         .write =        fb_write,
 995         .ioctl =        fb_ioctl,
 996 #ifdef CONFIG_COMPAT
 997         .compat_ioctl = fb_compat_ioctl,
 998 #endif
 999         .mmap =         fb_mmap,
1000         .open =         fb_open,
1001         .release =      fb_release,
1002 #ifdef HAVE_ARCH_FB_UNMAPPED_AREA
1003         .get_unmapped_area = get_fb_unmapped_area,
1004 #endif
1005 };
1006
1007 static struct class *fb_class;
1008
1009 /**
1010  *      register_framebuffer - registers a frame buffer device
1011  *      @fb_info: frame buffer info structure
1012  *
1013  *      Registers a frame buffer device @fb_info.
1014  *
1015  *      Returns negative errno on error, or zero for success.
1016  *
1017  */
1018
1019 int
1020 register_framebuffer(struct fb_info *fb_info)
1021 {
1022         int i;
1023         struct fb_event event;
1024         struct fb_videomode mode;
1025
1026         if (num_registered_fb == FB_MAX)
1027                 return -ENXIO;
1028         num_registered_fb++;
1029         for (i = 0 ; i < FB_MAX; i++)
1030                 if (!registered_fb[i])
1031                         break;
1032         fb_info->node = i;
1033
1034         fb_info->class_device = class_device_create(fb_class, NULL, MKDEV(FB_MAJOR, i),
1035                                     fb_info->device, "fb%d", i);
1036         if (IS_ERR(fb_info->class_device)) {
1037                 /* Not fatal */
1038                 printk(KERN_WARNING "Unable to create class_device for framebuffer %d; errno = %ld\n", i, PTR_ERR(fb_info->class_device));
1039                 fb_info->class_device = NULL;
1040         } else
1041                 fb_init_class_device(fb_info);
1042
1043         if (fb_info->pixmap.addr == NULL) {
1044                 fb_info->pixmap.addr = kmalloc(FBPIXMAPSIZE, GFP_KERNEL);
1045                 if (fb_info->pixmap.addr) {
1046                         fb_info->pixmap.size = FBPIXMAPSIZE;
1047                         fb_info->pixmap.buf_align = 1;
1048                         fb_info->pixmap.scan_align = 1;
1049                         fb_info->pixmap.access_align = 32;
1050                         fb_info->pixmap.flags = FB_PIXMAP_DEFAULT;
1051                 }
1052         }
1053         fb_info->pixmap.offset = 0;
1054
1055         if (!fb_info->modelist.prev || !fb_info->modelist.next)
1056                 INIT_LIST_HEAD(&fb_info->modelist);
1057
1058         fb_var_to_videomode(&mode, &fb_info->var);
1059         fb_add_videomode(&mode, &fb_info->modelist);
1060         registered_fb[i] = fb_info;
1061
1062         devfs_mk_cdev(MKDEV(FB_MAJOR, i),
1063                         S_IFCHR | S_IRUGO | S_IWUGO, "fb/%d", i);
1064         event.info = fb_info;
1065         notifier_call_chain(&fb_notifier_list,
1066                             FB_EVENT_FB_REGISTERED, &event);
1067         return 0;
1068 }
1069
1070
1071 /**
1072  *      unregister_framebuffer - releases a frame buffer device
1073  *      @fb_info: frame buffer info structure
1074  *
1075  *      Unregisters a frame buffer device @fb_info.
1076  *
1077  *      Returns negative errno on error, or zero for success.
1078  *
1079  */
1080
1081 int
1082 unregister_framebuffer(struct fb_info *fb_info)
1083 {
1084         int i;
1085
1086         i = fb_info->node;
1087         if (!registered_fb[i])
1088                 return -EINVAL;
1089         devfs_remove("fb/%d", i);
1090
1091         if (fb_info->pixmap.addr && (fb_info->pixmap.flags & FB_PIXMAP_DEFAULT))
1092                 kfree(fb_info->pixmap.addr);
1093         fb_destroy_modelist(&fb_info->modelist);
1094         registered_fb[i]=NULL;
1095         num_registered_fb--;
1096         fb_cleanup_class_device(fb_info);
1097         class_device_destroy(fb_class, MKDEV(FB_MAJOR, i));
1098         return 0;
1099 }
1100
1101 /**
1102  *      fb_register_client - register a client notifier
1103  *      @nb: notifier block to callback on events
1104  */
1105 int fb_register_client(struct notifier_block *nb)
1106 {
1107         return notifier_chain_register(&fb_notifier_list, nb);
1108 }
1109
1110 /**
1111  *      fb_unregister_client - unregister a client notifier
1112  *      @nb: notifier block to callback on events
1113  */
1114 int fb_unregister_client(struct notifier_block *nb)
1115 {
1116         return notifier_chain_unregister(&fb_notifier_list, nb);
1117 }
1118
1119 /**
1120  *      fb_set_suspend - low level driver signals suspend
1121  *      @info: framebuffer affected
1122  *      @state: 0 = resuming, !=0 = suspending
1123  *
1124  *      This is meant to be used by low level drivers to
1125  *      signal suspend/resume to the core & clients.
1126  *      It must be called with the console semaphore held
1127  */
1128 void fb_set_suspend(struct fb_info *info, int state)
1129 {
1130         struct fb_event event;
1131
1132         event.info = info;
1133         if (state) {
1134                 notifier_call_chain(&fb_notifier_list, FB_EVENT_SUSPEND, &event);
1135                 info->state = FBINFO_STATE_SUSPENDED;
1136         } else {
1137                 info->state = FBINFO_STATE_RUNNING;
1138                 notifier_call_chain(&fb_notifier_list, FB_EVENT_RESUME, &event);
1139         }
1140 }
1141
1142 /**
1143  *      fbmem_init - init frame buffer subsystem
1144  *
1145  *      Initialize the frame buffer subsystem.
1146  *
1147  *      NOTE: This function is _only_ to be called by drivers/char/mem.c.
1148  *
1149  */
1150
1151 static int __init
1152 fbmem_init(void)
1153 {
1154         create_proc_read_entry("fb", 0, NULL, fbmem_read_proc, NULL);
1155
1156         devfs_mk_dir("fb");
1157         if (register_chrdev(FB_MAJOR,"fb",&fb_fops))
1158                 printk("unable to get major %d for fb devs\n", FB_MAJOR);
1159
1160         fb_class = class_create(THIS_MODULE, "graphics");
1161         if (IS_ERR(fb_class)) {
1162                 printk(KERN_WARNING "Unable to create fb class; errno = %ld\n", PTR_ERR(fb_class));
1163                 fb_class = NULL;
1164         }
1165         return 0;
1166 }
1167
1168 #ifdef MODULE
1169 module_init(fbmem_init);
1170 static void __exit
1171 fbmem_exit(void)
1172 {
1173         class_destroy(fb_class);
1174         unregister_chrdev(FB_MAJOR, "fb");
1175 }
1176
1177 module_exit(fbmem_exit);
1178 MODULE_LICENSE("GPL");
1179 MODULE_DESCRIPTION("Framebuffer base");
1180 #else
1181 subsys_initcall(fbmem_init);
1182 #endif
1183
1184 int fb_new_modelist(struct fb_info *info)
1185 {
1186         struct fb_event event;
1187         struct fb_var_screeninfo var = info->var;
1188         struct list_head *pos, *n;
1189         struct fb_modelist *modelist;
1190         struct fb_videomode *m, mode;
1191         int err = 1;
1192
1193         list_for_each_safe(pos, n, &info->modelist) {
1194                 modelist = list_entry(pos, struct fb_modelist, list);
1195                 m = &modelist->mode;
1196                 fb_videomode_to_var(&var, m);
1197                 var.activate = FB_ACTIVATE_TEST;
1198                 err = fb_set_var(info, &var);
1199                 fb_var_to_videomode(&mode, &var);
1200                 if (err || !fb_mode_is_equal(m, &mode)) {
1201                         list_del(pos);
1202                         kfree(pos);
1203                 }
1204         }
1205
1206         err = 1;
1207
1208         if (!list_empty(&info->modelist)) {
1209                 event.info = info;
1210                 err = notifier_call_chain(&fb_notifier_list,
1211                                            FB_EVENT_NEW_MODELIST,
1212                                            &event);
1213         }
1214
1215         return err;
1216 }
1217
1218 static char *video_options[FB_MAX];
1219 static int ofonly;
1220
1221 extern const char *global_mode_option;
1222
1223 /**
1224  * fb_get_options - get kernel boot parameters
1225  * @name:   framebuffer name as it would appear in
1226  *          the boot parameter line
1227  *          (video=<name>:<options>)
1228  * @option: the option will be stored here
1229  *
1230  * NOTE: Needed to maintain backwards compatibility
1231  */
1232 int fb_get_options(char *name, char **option)
1233 {
1234         char *opt, *options = NULL;
1235         int opt_len, retval = 0;
1236         int name_len = strlen(name), i;
1237
1238         if (name_len && ofonly && strncmp(name, "offb", 4))
1239                 retval = 1;
1240
1241         if (name_len && !retval) {
1242                 for (i = 0; i < FB_MAX; i++) {
1243                         if (video_options[i] == NULL)
1244                                 continue;
1245                         opt_len = strlen(video_options[i]);
1246                         if (!opt_len)
1247                                 continue;
1248                         opt = video_options[i];
1249                         if (!strncmp(name, opt, name_len) &&
1250                             opt[name_len] == ':')
1251                                 options = opt + name_len + 1;
1252                 }
1253         }
1254         if (options && !strncmp(options, "off", 3))
1255                 retval = 1;
1256
1257         if (option)
1258                 *option = options;
1259
1260         return retval;
1261 }
1262
1263 /**
1264  *      video_setup - process command line options
1265  *      @options: string of options
1266  *
1267  *      Process command line options for frame buffer subsystem.
1268  *
1269  *      NOTE: This function is a __setup and __init function.
1270  *            It only stores the options.  Drivers have to call
1271  *            fb_get_options() as necessary.
1272  *
1273  *      Returns zero.
1274  *
1275  */
1276 static int __init video_setup(char *options)
1277 {
1278         int i, global = 0;
1279
1280         if (!options || !*options)
1281                 global = 1;
1282
1283         if (!global && !strncmp(options, "ofonly", 6)) {
1284                 ofonly = 1;
1285                 global = 1;
1286         }
1287
1288         if (!global && !strstr(options, "fb:")) {
1289                 global_mode_option = options;
1290                 global = 1;
1291         }
1292
1293         if (!global) {
1294                 for (i = 0; i < FB_MAX; i++) {
1295                         if (video_options[i] == NULL) {
1296                                 video_options[i] = options;
1297                                 break;
1298                         }
1299
1300                 }
1301         }
1302
1303         return 0;
1304 }
1305 __setup("video=", video_setup);
1306
1307     /*
1308      *  Visible symbols for modules
1309      */
1310
1311 EXPORT_SYMBOL(register_framebuffer);
1312 EXPORT_SYMBOL(unregister_framebuffer);
1313 EXPORT_SYMBOL(num_registered_fb);
1314 EXPORT_SYMBOL(registered_fb);
1315 EXPORT_SYMBOL(fb_prepare_logo);
1316 EXPORT_SYMBOL(fb_show_logo);
1317 EXPORT_SYMBOL(fb_set_var);
1318 EXPORT_SYMBOL(fb_blank);
1319 EXPORT_SYMBOL(fb_pan_display);
1320 EXPORT_SYMBOL(fb_get_buffer_offset);
1321 EXPORT_SYMBOL(fb_set_suspend);
1322 EXPORT_SYMBOL(fb_register_client);
1323 EXPORT_SYMBOL(fb_unregister_client);
1324 EXPORT_SYMBOL(fb_get_options);
1325 EXPORT_SYMBOL(fb_new_modelist);
1326
1327 MODULE_LICENSE("GPL");