Merge ../linux-2.6 by hand
[linux-2.6.git] / 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");