URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [uclinux/] [uClinux-2.0.x/] [drivers/] [char/] [fbmem.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 *  linux/drivers/char/fbmem.c
 *
 *  Copyright (C) 1994 Martin Schaller
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file COPYING in the main directory of this archive
 * for more details.
 *
 */
 
/*
 * uClinux revisions for NO_MM
 * Copyright (C) 1998  Kenneth Albanowski <kjahds@kjahds.com>,
 *                     The Silver Hammer Group, Ltd.
 */
 
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/malloc.h>
#include <linux/mman.h>
#include <linux/tty.h>
 
#include <asm/segment.h>
#include <asm/bootinfo.h>
#include <asm/page.h>
#include <asm/pgtable.h>
 
#include <linux/fb.h>
 
#define FB_MAJOR        29
 
#define FB_MODES_SHIFT    5     /* 32 modes per framebuffer */
#define FB_NUM_MINORS   256     /* 256 Minors               */
#define FB_MAX          (FB_NUM_MINORS / (1 << FB_MODES_SHIFT))
 
#define GET_INODE(i) MKDEV(FB_MAJOR, (i) << FB_MODES_SHIFT)
#define GET_FB_IDX(node) (MINOR(node) >> FB_MODES_SHIFT)
#define GET_FB_VAR_IDX(node) (MINOR(node) & ((1 << FB_MODES_SHIFT)-1)) 
 
struct fb_ops *registered_fb[FB_MAX];
struct fb_var_screeninfo *registered_fb_var[FB_MAX];
int registered_fb_var_num[FB_MAX];
int fb_curr_open[FB_MAX];
int fb_open_count[FB_MAX];
 
static inline int PROC_CONSOLE(void)
{
        if (!current->tty)
                return fg_console;
 
        if (current->tty->driver.type != TTY_DRIVER_TYPE_CONSOLE)
                /* XXX Should report error here? */
                return fg_console;
 
        if (MINOR(current->tty->device) < 1)
                return fg_console;
 
        return MINOR(current->tty->device) - 1;
}
 
static int
fb_read(struct inode *inode, struct file *file, char *buf, int count)
{
        unsigned long p = file->f_pos;
        struct fb_ops *fb = registered_fb[GET_FB_IDX(inode->i_rdev)];
        struct fb_fix_screeninfo fix;
        char *base_addr;
        int copy_size;
 
        if (! fb)
                return -ENODEV;
        if (count < 0)
                return -EINVAL;
 
        fb->fb_get_fix(&fix,PROC_CONSOLE());
        base_addr=(char *) fix.smem_start;
        copy_size=(count + p <= fix.smem_len ? count : fix.smem_len - p);
        memcpy_tofs(buf, base_addr+p, copy_size);
        file->f_pos += copy_size;
        return copy_size;
}
 
static int
fb_write(struct inode *inode, struct file *file, const char *buf, int count)
{
        unsigned long p = file->f_pos;
        struct fb_ops *fb = registered_fb[GET_FB_IDX(inode->i_rdev)];
        struct fb_fix_screeninfo fix;
        char *base_addr;
        int copy_size;
 
        if (! fb)
                return -ENODEV;
        if (count < 0)
                return -EINVAL;
        fb->fb_get_fix(&fix, PROC_CONSOLE());
        base_addr=(char *) fix.smem_start;
        copy_size=(count + p <= fix.smem_len ? count : fix.smem_len - p);
        memcpy_fromfs(base_addr+p, buf, copy_size);
        file->f_pos += copy_size;
        return copy_size;
}
 
 
static int
fb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         unsigned long arg)
{
        struct fb_ops *fb = registered_fb[GET_FB_IDX(inode->i_rdev)];
        struct fb_cmap cmap;
        struct fb_var_screeninfo var;
        struct fb_fix_screeninfo fix;
 
        int i,fbidx,vidx;
 
        if (! fb)
                return -ENODEV;
        switch (cmd) {
        case FBIOGET_VSCREENINFO:
                i = verify_area(VERIFY_WRITE, (void *) arg,
                                sizeof(struct fb_var_screeninfo));
                if (i) return i;
                fbidx=GET_FB_IDX(inode->i_rdev);
                vidx=GET_FB_VAR_IDX(inode->i_rdev);
                if (! vidx) /* ask device driver for current */
                        i=fb->fb_get_var(&var, PROC_CONSOLE());
                else
                        var=registered_fb_var[fbidx][vidx-1];
                memcpy_tofs((void *) arg, &var, sizeof(var));
                return i;
        case FBIOPUT_VSCREENINFO:
                i = verify_area(VERIFY_WRITE, (void *) arg,
                                sizeof(struct fb_var_screeninfo));
                if (i) return i;
                memcpy_fromfs(&var, (void *) arg, sizeof(var));
                i=fb->fb_set_var(&var, PROC_CONSOLE());
                memcpy_tofs((void *) arg, &var, sizeof(var));
                fbidx=GET_FB_IDX(inode->i_rdev);
                vidx=GET_FB_VAR_IDX(inode->i_rdev);
                if (! i && vidx)
                        registered_fb_var[fbidx][vidx-1]=var;
                return i;
        case FBIOGET_FSCREENINFO:
                i = verify_area(VERIFY_WRITE, (void *) arg,
                                sizeof(struct fb_fix_screeninfo));
                if (i)  return i;
                i=fb->fb_get_fix(&fix, PROC_CONSOLE());
                memcpy_tofs((void *) arg, &fix, sizeof(fix));
                return i;
        case FBIOPUTCMAP:
                i = verify_area(VERIFY_READ, (void *) arg,
                                sizeof(struct fb_cmap));
                if (i) return i;
                memcpy_fromfs(&cmap, (void *) arg, sizeof(cmap));
                i = verify_area(VERIFY_READ, (void *) cmap.red,
                                cmap.len * sizeof(unsigned short));
                if (i) return i;
                i = verify_area(VERIFY_READ, (void *) cmap.green,
                                cmap.len * sizeof(unsigned short));
                if (i) return i;
                i = verify_area(VERIFY_READ, (void *) cmap.blue,
                                cmap.len * sizeof(unsigned short));
                if (i) return i;
                if (cmap.transp) {
                        i = verify_area(VERIFY_READ, (void *) cmap.transp,
                                        cmap.len * sizeof(unsigned short));
                        if (i) return i;
                }
                return (fb->fb_set_cmap(&cmap, 0, PROC_CONSOLE()));
        case FBIOGETCMAP:
                i = verify_area(VERIFY_READ, (void *) arg,
                                sizeof(struct fb_cmap));
                if (i)  return i;
                memcpy_fromfs(&cmap, (void *) arg, sizeof(cmap));
                i = verify_area(VERIFY_WRITE, (void *) cmap.red,
                                cmap.len * sizeof(unsigned short));
                if (i) return i;
                i = verify_area(VERIFY_WRITE, (void *) cmap.green,
                                cmap.len * sizeof(unsigned short));
                if (i) return i;
                i = verify_area(VERIFY_WRITE, (void *) cmap.blue,
                                cmap.len * sizeof(unsigned short));
                if (i) return i;
                if (cmap.transp) {
                        i = verify_area(VERIFY_WRITE, (void *) cmap.transp,
                                        cmap.len * sizeof(unsigned short));
                        if (i) return i;
                }
                return (fb->fb_get_cmap(&cmap, 0, PROC_CONSOLE()));
        case FBIOPAN_DISPLAY:
                i = verify_area(VERIFY_WRITE, (void *) arg,
                                sizeof(struct fb_var_screeninfo));
                if (i) return i;
                memcpy_fromfs(&var, (void *) arg, sizeof(var));
                i=fb->fb_pan_display(&var, PROC_CONSOLE());
                memcpy_tofs((void *) arg, &var, sizeof(var));
                fbidx=GET_FB_IDX(inode->i_rdev);
                vidx=GET_FB_VAR_IDX(inode->i_rdev);
                if (! i && vidx)
                        registered_fb_var[fbidx][vidx-1]=var;
                return i;
        default:
                return (fb->fb_ioctl(inode, file, cmd, arg, PROC_CONSOLE()));
        }
}
 
static int
fb_mmap(struct inode *inode, struct file *file, struct vm_area_struct * vma)
{
        struct fb_ops *fb = registered_fb[GET_FB_IDX(inode->i_rdev)];
        struct fb_fix_screeninfo fix;
 
        if (! fb)
                return -ENODEV;
        fb->fb_get_fix(&fix, PROC_CONSOLE());
#ifndef NO_MM
        if ((vma->vm_end - vma->vm_start + vma->vm_offset) > fix.smem_len)
                return -EINVAL;
        vma->vm_offset += fix.smem_start;
        if (vma->vm_offset & ~PAGE_MASK)
                return -ENXIO;
        if (m68k_is040or060) {
                pgprot_val(vma->vm_page_prot) &= _CACHEMASK040;
                /* Use write-through cache mode */
                pgprot_val(vma->vm_page_prot) |= _PAGE_CACHE040W;
        }
        if (remap_page_range(vma->vm_start, vma->vm_offset,
                             vma->vm_end - vma->vm_start, vma->vm_page_prot))
                return -EAGAIN;
        vma->vm_inode = inode;
        inode->i_count++;
#else /* !NO_MM */
        vma->vm_start = fix.smem_start+vma->vm_offset;
#endif /* !NO_MM */
        return 0;
}
 
static int
fb_open(struct inode *inode, struct file *file)
{
        int fbidx=GET_FB_IDX(inode->i_rdev);
        int vidx=GET_FB_VAR_IDX(inode->i_rdev);
        struct fb_ops *fb = registered_fb[fbidx];
        int err;
 
        if (! vidx)             /* fb?current always succeeds */
                return 0;
        if (vidx > registered_fb_var_num[fbidx])
                return -EINVAL;
        if (fb_curr_open[fbidx] && fb_curr_open[fbidx] != vidx)
                return -EBUSY;
        if (file->f_mode & 2) /* only set parameters if opened writeable */
                if ((err=fb->fb_set_var(registered_fb_var[fbidx] + vidx-1, PROC_CONSOLE())))
                        return err;
        fb_curr_open[fbidx] = vidx;
        fb_open_count[fbidx]++;
        return 0;
}
 
static void
fb_release(struct inode *inode, struct file *file)
{
        int fbidx=GET_FB_IDX(inode->i_rdev);
        int vidx=GET_FB_VAR_IDX(inode->i_rdev);
        if (! vidx)
                return;
        if (! (--fb_open_count[fbidx]))
                fb_curr_open[fbidx]=0;
}
 
static struct file_operations fb_fops = {
        NULL,           /* lseek        */
        fb_read,        /* read         */
        fb_write,       /* write        */
        NULL,           /* readdir      */
        NULL,           /* select       */
        fb_ioctl,       /* ioctl        */
        fb_mmap,        /* mmap         */
        fb_open,        /* open         */
        fb_release,     /* release      */
        NULL            /* fsync        */
};
 
int
register_framebuffer(char *id, int *node, struct fb_ops *fbops, int fbvar_num,
                     struct fb_var_screeninfo *fbvar)
{
        int i;
        for (i = 0 ; i < FB_MAX; i++)
                if (! registered_fb[i])
                        break;
        if (i == FB_MAX)
                return -ENXIO;
        registered_fb[i]=fbops;
        registered_fb_var[i]=fbvar;
        registered_fb_var_num[i]=fbvar_num;
        *node=GET_INODE(i);
        return 0;
}
 
int
unregister_framebuffer(int node)
{
        int i=GET_FB_IDX(node);
        if (! registered_fb[i])
                return -EINVAL;
        registered_fb[i]=NULL;
        registered_fb_var[i]=NULL;
        return 0;
}
 
int
fbmem_init(void)
{
        if (register_chrdev(FB_MAJOR,"fb",&fb_fops))
                printk("unable to get major %d for fb devs\n", FB_MAJOR);
        return 0;
}
 

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [uclinux/] [uClinux-2.0.x/] [drivers/] [char/] [fbmem.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	199	simons	`/*`
2			`* linux/drivers/char/fbmem.c`
3			`*`
4			`* Copyright (C) 1994 Martin Schaller`
5			`*`
6			`* This file is subject to the terms and conditions of the GNU General Public`
7			`* License. See the file COPYING in the main directory of this archive`
8			`* for more details.`
9			`*`
10			`*/`
11
12			`/*`
13			`* uClinux revisions for NO_MM`
14			`* Copyright (C) 1998 Kenneth Albanowski <kjahds@kjahds.com>,`
15			`* The Silver Hammer Group, Ltd.`
16			`*/`
17
18			`#include <linux/types.h>`
19			`#include <linux/errno.h>`
20			`#include <linux/sched.h>`
21			`#include <linux/kernel.h>`
22			`#include <linux/major.h>`
23			`#include <linux/malloc.h>`
24			`#include <linux/mman.h>`
25			`#include <linux/tty.h>`
26
27			`#include <asm/segment.h>`
28			`#include <asm/bootinfo.h>`
29			`#include <asm/page.h>`
30			`#include <asm/pgtable.h>`
31
32			`#include <linux/fb.h>`
33
34			`#define FB_MAJOR 29`
35
36			`#define FB_MODES_SHIFT 5 /* 32 modes per framebuffer */`
37			`#define FB_NUM_MINORS 256 /* 256 Minors */`
38			`#define FB_MAX (FB_NUM_MINORS / (1 << FB_MODES_SHIFT))`
39
40			`#define GET_INODE(i) MKDEV(FB_MAJOR, (i) << FB_MODES_SHIFT)`
41			`#define GET_FB_IDX(node) (MINOR(node) >> FB_MODES_SHIFT)`
42			`#define GET_FB_VAR_IDX(node) (MINOR(node) & ((1 << FB_MODES_SHIFT)-1))`
43
44			`struct fb_ops *registered_fb[FB_MAX];`
45			`struct fb_var_screeninfo *registered_fb_var[FB_MAX];`
46			`int registered_fb_var_num[FB_MAX];`
47			`int fb_curr_open[FB_MAX];`
48			`int fb_open_count[FB_MAX];`
49
50			`static inline int PROC_CONSOLE(void)`
51			`{`
52			`if (!current->tty)`
53			`return fg_console;`
54
55			`if (current->tty->driver.type != TTY_DRIVER_TYPE_CONSOLE)`
56			`/* XXX Should report error here? */`
57			`return fg_console;`
58
59			`if (MINOR(current->tty->device) < 1)`
60			`return fg_console;`
61
62			`return MINOR(current->tty->device) - 1;`
63			`}`
64
65			`static int`
66			`fb_read(struct inode inode, struct file file, char *buf, int count)`
67			`{`
68			`unsigned long p = file->f_pos;`
69			`struct fb_ops *fb = registered_fb[GET_FB_IDX(inode->i_rdev)];`
70			`struct fb_fix_screeninfo fix;`
71			`char *base_addr;`
72			`int copy_size;`
73
74			`if (! fb)`
75			`return -ENODEV;`
76			`if (count < 0)`
77			`return -EINVAL;`
78
79			`fb->fb_get_fix(&fix,PROC_CONSOLE());`
80			`base_addr=(char *) fix.smem_start;`
81			`copy_size=(count + p <= fix.smem_len ? count : fix.smem_len - p);`
82			`memcpy_tofs(buf, base_addr+p, copy_size);`
83			`file->f_pos += copy_size;`
84			`return copy_size;`
85			`}`
86
87			`static int`
88			`fb_write(struct inode inode, struct file file, const char *buf, int count)`
89			`{`
90			`unsigned long p = file->f_pos;`
91			`struct fb_ops *fb = registered_fb[GET_FB_IDX(inode->i_rdev)];`
92			`struct fb_fix_screeninfo fix;`
93			`char *base_addr;`
94			`int copy_size;`
95
96			`if (! fb)`
97			`return -ENODEV;`
98			`if (count < 0)`
99			`return -EINVAL;`
100			`fb->fb_get_fix(&fix, PROC_CONSOLE());`
101			`base_addr=(char *) fix.smem_start;`
102			`copy_size=(count + p <= fix.smem_len ? count : fix.smem_len - p);`
103			`memcpy_fromfs(base_addr+p, buf, copy_size);`
104			`file->f_pos += copy_size;`
105			`return copy_size;`
106			`}`
107
108
109			`static int`
110			`fb_ioctl(struct inode inode, struct file file, unsigned int cmd,`
111			`unsigned long arg)`
112			`{`
113			`struct fb_ops *fb = registered_fb[GET_FB_IDX(inode->i_rdev)];`
114			`struct fb_cmap cmap;`
115			`struct fb_var_screeninfo var;`
116			`struct fb_fix_screeninfo fix;`
117
118			`int i,fbidx,vidx;`
119
120			`if (! fb)`
121			`return -ENODEV;`
122			`switch (cmd) {`
123			`case FBIOGET_VSCREENINFO:`
124			`i = verify_area(VERIFY_WRITE, (void *) arg,`
125			`sizeof(struct fb_var_screeninfo));`
126			`if (i) return i;`
127			`fbidx=GET_FB_IDX(inode->i_rdev);`
128			`vidx=GET_FB_VAR_IDX(inode->i_rdev);`
129			`if (! vidx) /* ask device driver for current */`
130			`i=fb->fb_get_var(&var, PROC_CONSOLE());`
131			`else`
132			`var=registered_fb_var[fbidx][vidx-1];`
133			`memcpy_tofs((void *) arg, &var, sizeof(var));`
134			`return i;`
135			`case FBIOPUT_VSCREENINFO:`
136			`i = verify_area(VERIFY_WRITE, (void *) arg,`
137			`sizeof(struct fb_var_screeninfo));`
138			`if (i) return i;`
139			`memcpy_fromfs(&var, (void *) arg, sizeof(var));`
140			`i=fb->fb_set_var(&var, PROC_CONSOLE());`
141			`memcpy_tofs((void *) arg, &var, sizeof(var));`
142			`fbidx=GET_FB_IDX(inode->i_rdev);`
143			`vidx=GET_FB_VAR_IDX(inode->i_rdev);`
144			`if (! i && vidx)`
145			`registered_fb_var[fbidx][vidx-1]=var;`
146			`return i;`
147			`case FBIOGET_FSCREENINFO:`
148			`i = verify_area(VERIFY_WRITE, (void *) arg,`
149			`sizeof(struct fb_fix_screeninfo));`
150			`if (i) return i;`
151			`i=fb->fb_get_fix(&fix, PROC_CONSOLE());`
152			`memcpy_tofs((void *) arg, &fix, sizeof(fix));`
153			`return i;`
154			`case FBIOPUTCMAP:`
155			`i = verify_area(VERIFY_READ, (void *) arg,`
156			`sizeof(struct fb_cmap));`
157			`if (i) return i;`
158			`memcpy_fromfs(&cmap, (void *) arg, sizeof(cmap));`
159			`i = verify_area(VERIFY_READ, (void *) cmap.red,`
160			`cmap.len * sizeof(unsigned short));`
161			`if (i) return i;`
162			`i = verify_area(VERIFY_READ, (void *) cmap.green,`
163			`cmap.len * sizeof(unsigned short));`
164			`if (i) return i;`
165			`i = verify_area(VERIFY_READ, (void *) cmap.blue,`
166			`cmap.len * sizeof(unsigned short));`
167			`if (i) return i;`
168			`if (cmap.transp) {`
169			`i = verify_area(VERIFY_READ, (void *) cmap.transp,`
170			`cmap.len * sizeof(unsigned short));`
171			`if (i) return i;`
172			`}`
173			`return (fb->fb_set_cmap(&cmap, 0, PROC_CONSOLE()));`
174			`case FBIOGETCMAP:`
175			`i = verify_area(VERIFY_READ, (void *) arg,`
176			`sizeof(struct fb_cmap));`
177			`if (i) return i;`
178			`memcpy_fromfs(&cmap, (void *) arg, sizeof(cmap));`
179			`i = verify_area(VERIFY_WRITE, (void *) cmap.red,`
180			`cmap.len * sizeof(unsigned short));`
181			`if (i) return i;`
182			`i = verify_area(VERIFY_WRITE, (void *) cmap.green,`
183			`cmap.len * sizeof(unsigned short));`
184			`if (i) return i;`
185			`i = verify_area(VERIFY_WRITE, (void *) cmap.blue,`
186			`cmap.len * sizeof(unsigned short));`
187			`if (i) return i;`
188			`if (cmap.transp) {`
189			`i = verify_area(VERIFY_WRITE, (void *) cmap.transp,`
190			`cmap.len * sizeof(unsigned short));`
191			`if (i) return i;`
192			`}`
193			`return (fb->fb_get_cmap(&cmap, 0, PROC_CONSOLE()));`
194			`case FBIOPAN_DISPLAY:`
195			`i = verify_area(VERIFY_WRITE, (void *) arg,`
196			`sizeof(struct fb_var_screeninfo));`
197			`if (i) return i;`
198			`memcpy_fromfs(&var, (void *) arg, sizeof(var));`
199			`i=fb->fb_pan_display(&var, PROC_CONSOLE());`
200			`memcpy_tofs((void *) arg, &var, sizeof(var));`
201			`fbidx=GET_FB_IDX(inode->i_rdev);`
202			`vidx=GET_FB_VAR_IDX(inode->i_rdev);`
203			`if (! i && vidx)`
204			`registered_fb_var[fbidx][vidx-1]=var;`
205			`return i;`
206			`default:`
207			`return (fb->fb_ioctl(inode, file, cmd, arg, PROC_CONSOLE()));`
208			`}`
209			`}`
210
211			`static int`
212			`fb_mmap(struct inode inode, struct file file, struct vm_area_struct * vma)`
213			`{`
214			`struct fb_ops *fb = registered_fb[GET_FB_IDX(inode->i_rdev)];`
215			`struct fb_fix_screeninfo fix;`
216
217			`if (! fb)`
218			`return -ENODEV;`
219			`fb->fb_get_fix(&fix, PROC_CONSOLE());`
220			`#ifndef NO_MM`
221			`if ((vma->vm_end - vma->vm_start + vma->vm_offset) > fix.smem_len)`
222			`return -EINVAL;`
223			`vma->vm_offset += fix.smem_start;`
224			`if (vma->vm_offset & ~PAGE_MASK)`
225			`return -ENXIO;`
226			`if (m68k_is040or060) {`
227			`pgprot_val(vma->vm_page_prot) &= _CACHEMASK040;`
228			`/* Use write-through cache mode */`
229			`pgprot_val(vma->vm_page_prot) \|= _PAGE_CACHE040W;`
230			`}`
231			`if (remap_page_range(vma->vm_start, vma->vm_offset,`
232			`vma->vm_end - vma->vm_start, vma->vm_page_prot))`
233			`return -EAGAIN;`
234			`vma->vm_inode = inode;`
235			`inode->i_count++;`
236			`#else /* !NO_MM */`
237			`vma->vm_start = fix.smem_start+vma->vm_offset;`
238			`#endif /* !NO_MM */`
239			`return 0;`
240			`}`
241
242			`static int`
243			`fb_open(struct inode inode, struct file file)`
244			`{`
245			`int fbidx=GET_FB_IDX(inode->i_rdev);`
246			`int vidx=GET_FB_VAR_IDX(inode->i_rdev);`
247			`struct fb_ops *fb = registered_fb[fbidx];`
248			`int err;`
249
250			`if (! vidx) /* fb?current always succeeds */`
251			`return 0;`
252			`if (vidx > registered_fb_var_num[fbidx])`
253			`return -EINVAL;`
254			`if (fb_curr_open[fbidx] && fb_curr_open[fbidx] != vidx)`
255			`return -EBUSY;`
256			`if (file->f_mode & 2) /* only set parameters if opened writeable */`
257			`if ((err=fb->fb_set_var(registered_fb_var[fbidx] + vidx-1, PROC_CONSOLE())))`
258			`return err;`
259			`fb_curr_open[fbidx] = vidx;`
260			`fb_open_count[fbidx]++;`
261			`return 0;`
262			`}`
263
264			`static void`
265			`fb_release(struct inode inode, struct file file)`
266			`{`
267			`int fbidx=GET_FB_IDX(inode->i_rdev);`
268			`int vidx=GET_FB_VAR_IDX(inode->i_rdev);`
269			`if (! vidx)`
270			`return;`
271			`if (! (--fb_open_count[fbidx]))`
272			`fb_curr_open[fbidx]=0;`
273			`}`
274
275			`static struct file_operations fb_fops = {`
276			`NULL, /* lseek */`
277			`fb_read, /* read */`
278			`fb_write, /* write */`
279			`NULL, /* readdir */`
280			`NULL, /* select */`
281			`fb_ioctl, /* ioctl */`
282			`fb_mmap, /* mmap */`
283			`fb_open, /* open */`
284			`fb_release, /* release */`
285			`NULL /* fsync */`
286			`};`
287
288			`int`
289			`register_framebuffer(char id, int node, struct fb_ops *fbops, int fbvar_num,`
290			`struct fb_var_screeninfo *fbvar)`
291			`{`
292			`int i;`
293			`for (i = 0 ; i < FB_MAX; i++)`
294			`if (! registered_fb[i])`
295			`break;`
296			`if (i == FB_MAX)`
297			`return -ENXIO;`
298			`registered_fb[i]=fbops;`
299			`registered_fb_var[i]=fbvar;`
300			`registered_fb_var_num[i]=fbvar_num;`
301			`*node=GET_INODE(i);`
302			`return 0;`
303			`}`
304
305			`int`
306			`unregister_framebuffer(int node)`
307			`{`
308			`int i=GET_FB_IDX(node);`
309			`if (! registered_fb[i])`
310			`return -EINVAL;`
311			`registered_fb[i]=NULL;`
312			`registered_fb_var[i]=NULL;`
313			`return 0;`
314			`}`
315
316			`int`
317			`fbmem_init(void)`
318			`{`
319			`if (register_chrdev(FB_MAJOR,"fb",&fb_fops))`
320			`printk("unable to get major %d for fb devs\n", FB_MAJOR);`
321			`return 0;`
322			`}`
323